哈希表与直线点的记录--直线上最多的点数计算

题目

oj平台

---

题目解析

• 此题有两种思路解决，但是无一例外都是需要用到哈希表。

1. 第一种解法：通过记录直线的斜率和截距。
   具体步骤：

• 写出用于计算任意两点之间斜率和截距的函数，返回值为二元组。
• 枚举任意两点的斜率和截距，当两者均相同时视为同一直线上的点，以斜率和截距为 key ，点的编号为 value ，通过哈希表记录下来，如果满足 key 相同则需要判断点是否已经出现过，若出现则不需记录该点(正好可用 set ).
• 更新答案为 key 对应的点最多的个数，即为直线上最多的点数。

2. 第二种解法：通过记录直线的斜率。
   具体方法(依据该方法论，基本步骤就能成型)：

• 由于只通过斜率来判断是否为同一直线，很显然可能存在重合，那么这种情况如何解决呢？我们可以在枚举的过程中解决，我们只需要每一轮对一个点进行所有情况的枚举(取任意另外一点进行更新斜率)，并且每一轮情况都单独用一个哈希表解决(非常重要)，也就是换点进行枚举时，重新记录各个斜率情况，那么就不会存在重复计算的情况了。

如何算斜率？这个实际上也是一门学问，我们可以用除法得到小数计算，但是这样实际上还是会出现一定的精度损失，最好的办法还是用一个二元组表示，但是需要把二元组化为最简的分数形式！

• 如何把分数二元组化到最简？
  我们可以同时把分子分母除以最大公因数实现最简的分数形式。

gcd函数(辗转相除法)实现：

int gcd(int a,int b){
	return b ? gcd(b,a%b) : a;
}

第一种解法

效率一般般：

class Solution {
public:
    int maxPoints(vector<vector<int>>& points) {
        int size = points.size();
        if(size==1)
            return 1;
        //任意两点的选择
        int res = 0;
        for(int i=0;i<size;i++){
            for(int j=i+1;j<size;j++){
            //右值引用
                pair<double,double>&& t =  solve(points[i],points[j]);
                auto q = times.find(t);
                if(q!=times.end()){
                //左值引用
                    set<int>&s = q->second;
                    s.insert(i);
                    s.insert(j);
                    int x = s.size();
                    res = max(res,x);
                }else{
                     set<int>&s = times[t];
                    s.insert(i);
                    s.insert(j);
                    int x = s.size();
                    res = max(res,x);
                }
        }
    }
    return res;
}
private:
//hash表用于记录位于同一直线的点的数目
map<pair<double,double>,set<int>>times;
//用于返回k,b以辨认是否为同一直线
    pair<double,double> solve(vector<int>& point1,vector<int>& point2){
        if(point1[0]==point2[0])return {INT_MAX,point1[0]};
        double k = (double)(point1[1]-point2[1])/(point1[0]-point2[0]);
        double b = -k*point1[0]+point1[1];
        return {k,b};
    }
};

第二种解法

效率yyds

class Solution {
public:
    int gcd(int a, int b) {
        return b ? gcd(b, a % b) : a;
    }

    int maxPoints(vector<vector<int>>& points) {
        int n = points.size();
        if (n <= 2) {
            return n;
        }
        int ret = 0;
        for (int i = 0; i < n; i++) {
            //对于每一轮的枚举建立不同的哈希表，在末尾直接对最大结果进行更新
            unordered_map<int, int> mp;
            for (int j = i + 1; j < n; j++) {
                int x = points[i][0] - points[j][0];
                int y = points[i][1] - points[j][1];
                //对于特殊情况的分数二元组进行特殊处理
                if (x == 0) {
                    y = 1;
                } else if (y == 0) {
                    x = 1;
                } else {
                    //对二元组的正负进行统一
                    if (y < 0) {
                        x = -x;
                        y = -y;
                    }
                    //化简二元组
                    int&& gcdXY = gcd(abs(x), abs(y));
                    x /= gcdXY, y /= gcdXY;
                }
                //对当前的mp进行更新
                mp[y + x * 20001]++;
            }
//根据当前mp记录的答案更新最大值。（注意由于mp中值记录的是有多少个点和该点同斜率，故还需要+1包括自身）
            for (auto& [_, num] : mp) {
                ret = max(ret, num + 1);
            }
        }
        return ret;
    }
};