【LeetCode】Max Points on a Line_leetcode max-points-on-a-line 完整代码-优快云博客

本文链接：https://blog.youkuaiyun.com/snowwolf_yang/article/details/22721263

本文介绍了一种使用哈希映射来解决寻找二维平面上共线点最大数量的问题的方法。通过固定一个点并计算该点与其他所有点之间的斜率，利用哈希映射统计斜率出现的次数，从而找到共线点的最大数量。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

参考：

http://blog.youkuaiyun.com/ict2014/article/details/17400345

题目：

Max Points on a Line

Given n points on a 2D plane, find the maximum number of points that lie on the same straight line.

题目分析：

题目大意：

给出共线的点的最大数量。就是说平面上有很多点，总有一些点花线，给出在同在一条直线的点的最大数量。

这里用map方法就非常好。做一个斜率到点数量的映射。

先固定一个点，然后依次计算这个点到其他点的斜率。计算出和固定点连线各个斜率的数量。

找出相同斜率数量的最大值。

然后下一个点，同样的方法找出最大值，然后和之前的最大值比较，如果比之前记录的最大值大，就更新，否则就继续下一个点。

直到倒数第二个点。

注意事项：

如果现在固定第k个点，那个k点之前的点不需要再加入统计之中。因为k点之前的点和k点的斜率数量已经统计过了，不需要再统计。

易错点：

点数小于3个点返回点数

斜率不存在。

重叠点

代码：

/**
 * Definition for a point.
 * struct Point {
 *     int x;
 *     int y;
 *     Point() : x(0), y(0) {}
 *     Point(int a, int b) : x(a), y(b) {}
 * };
 */
class Solution {
public:
    int maxPoints(vector<Point> &points) {
        map<double,int> mp;
        int point_size = points.size();
        if(point_size < 3) return point_size;///////////////////////////
        int max_points = 2;
        for(int i = 0;i < point_size-1; i++) {
            int same_point_to_i_size = 1;
            int k_is_infinite_size = 0;
            mp.clear();
            for(int j = i+1;j<point_size;j++) {
                if(points[i].x == points[j].x) {
                    if(points[i].y == points[j].y)
                        same_point_to_i_size++;///////////////////////////////////
                    else
                        k_is_infinite_size++;////////////////////////////////
                    continue;
                }
                double k = (double)(points[i].y - points[j].y) / (double)(points[i].x - points[j].x);
                mp[k]++;
            }
            if(max_points < same_point_to_i_size + k_is_infinite_size)
                max_points = same_point_to_i_size + k_is_infinite_size;
            map<double,int>::iterator it = mp.begin();
            for(;it != mp.end();it++)
            {
                if(max_points < same_point_to_i_size + it->second)
                    max_points = same_point_to_i_size + it->second;
            }
        }
        return max_points;
    }
};

/*
编译环境CFree 5.0
博客地址：http://blog.youkuaiyun.com/Snowwolf_Yang
*/

#include 
   
    
#include 
    
     
#include 
     

using namespace std;

/*
功能测试 
注意特殊输入 0个点 1个点 2个点 重叠点，无斜率点 
 
*/
/**
 * Definition for a point.
 * struct Point {
 *     int x;
 *     int y;
 *     Point() : x(0), y(0) {}
 *     Point(int a, int b) : x(a), y(b) {}
 * };
 */
struct Point {
	int x;
	int y;
	Point() : x(0), y(0) {}
	Point(int a, int b) : x(a), y(b) {}
	};
class Solution { 	
public:  
    int maxPoints(vector
      
        &points) { 
    	if(points.empty())//没点
			return 0;
		
		int points_size = points.size();
		if(points_size < 3)
			return points_size; //如果是1个点或两个点返回点数 
		map
       
         lines;
		
		int i = 0, j = 0, max_num = 0;
		int total_same = 1;//和 i 重合的点的个数
		int total_inf = 0;//斜率不存在的点个数 		注意初始值。 最后点数应该是起点数 加上斜率相同的点数 
		double k = 0;
		for(i = 0;i
        
         ::iterator it; for(it = lines.begin();it != lines.end();it++) { if(it->second > total_inf) total_inf = it->second; } //这里 total_inf 记录了相同斜率数的最大值 if(max_num
         
           points; for(i=0;i<5;i++) { points.push_back(Point(tmppoint[i][0],tmppoint[i][1])); } Solution so; cout<<"maxPoint = "<
          
           <

/**
 * Definition for a point.
 * struct Point {
 *     int x;
 *     int y;
 *     Point() : x(0), y(0) {}
 *     Point(int a, int b) : x(a), y(b) {}
 * };
 */
class Solution {
public:
    int maxPoints(vector<Point> &points) {
        int size = points.size();
        if(size < 3)   return size;/////////////////////////////需要考虑小于3个点
        map<double,int> mp;
        int max_points = 1;/////////////////////////////////
        for(int i = 0;i<size-1;i++)
        {
            mp.clear();
            int noK = 0, same_point = 1;
            for(int j = i+1;j<size;j++)
            {
                if(points[i].x == points[j].x)
                {
                    if(points[i].y == points[j].y)
                        same_point++;
                    else
                        noK++;
                    continue;//////////////////////////////
                }
                double k = (double)(points[i].y - points[j].y)/(points[i].x - points[j].x);//////////////////////这里必须显式类型转换
                mp[k]++;
            }
            map<double,int>::iterator it;
            for(it = mp.begin();it != mp.end();it++)
            {
                max_points = max(max_points,same_point+it->second);
            }
            max_points = max(max_points,same_point+noK);
        }
        return max_points;
    }
};