LeetCode 149 直线上最多的点数[数学 几何 哈希表] HERODING的LeetCode之路

Posted 2021-06-30 HERODING23

解题思路：
虽然是个困难题，但是思路很简单，就是遍历任意两个点，然后比较与其他点的斜率是否相同，找到最大值即可，这样操作下来时间复杂度为O(n^3)，代码如下：

class Solution {
public:
    int maxPoints(vector<vector<int>>& points) {
        int len = points.size();
        // 点的数量不够
        if(len < 3) {
            return len;
        }
        int maxNum = 2;
        // 遍历每两个点
        for(int i = 0; i < len - 1; i ++) {
            for(int j = i + 1; j < len; j ++) {
                // 统计斜率相等个数
                int count = 2;
                long long dx = points[i][0] - points[j][0];
                long long dy = points[i][1] - points[j][1];
                // 与其他点比较
                for(int k = j + 1; k < len; k ++) {
                    // 如果斜率相等
                    if(dx * (points[i][1] - points[k][1]) == dy * (points[i][0] - points[k][0])) {
                        count ++;
                    }
                }
                maxNum = max(maxNum, count);
                if(maxNum > len / 2) return maxNum;
            }  
        }
        return maxNum;
    }
};

当然时间复杂度还可以化简，就是用哈希表的方式存储斜率，统计最多数目的的斜率即可，代码如下：

class Solution {
public:
    int maxPoints(vector<vector<int>>& points) {
        int len = points.size();
        // 点的数量不够
        if(len < 3) {
            return len;
        }
        int maxNum = 2;
        // 遍历每两个点
        for(int i = 0; i < len; i ++) {
            unordered_map<double, int> count;
            for(int j = 0; j < len; j ++) {
                if(i != j) {
                    long long dx = points[i][0] - points[j][0];
                    long long dy = points[i][1] - points[j][1];
                    double gradient = dy * 1.0 / dx;
                    if(count.count(gradient)) {
                        count[gradient] ++;
                    } else {
                        count[gradient] = 2;
                    }
                    maxNum = max(maxNum, count[gradient]);
                } 
            }  
        }
        return maxNum;
    }
};