[LeetCode] 149. Max Points on a Line

Given an array of points where points[i] = [xi, yi] represents a point on the X-Y plane, return the maximum number of points that lie on the same straight line.

Example 1:

Input: points = [[1,1],[2,2],[3,3]]
Output: 3

Example 2:

Input: points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
Output: 4

Constraints:

• 1 <= points.length <= 300
• points[i].length == 2
• -104 <= xi, yi <= 104
• All the points are unique.

直线上最多的点数。

给你一个数组 points ，其中 points[i] = [xi, yi] 表示 X-Y 平面上的一个点。求最多有多少个点在同一条直线上。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/max-points-on-a-line
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这是一道数学题。暴力解不难想，难的是如何优化。

我们知道，两点确定一条直线，也就有了这条直线的斜率 slope。暴力解的做法是三层 for 循环。用第一层 for 循环找到第一个点，用第二层 for 循环找到第二个点，再用第三层 for 循环找到第三个点，比较点一 - 点二和点二 - 点三的斜率是否一样。

时间O(n^3)

空间O(1)

Java实现

class Solution {
    public int maxPoints(int[][] points) {
        int len = points.length;
        int res = 1;
        for (int i = 0; i < len; i++) {
            int[] first = points[i];
            for (int j = i + 1; j < len; j++) {
                int[] second = points[j];
                int count = 2;
                for (int k = j + 1; k < len; k++) {
                    int[] third = points[k];
                    int slope1 = (second[1] - first[1]) * (third[0] - second[0]);
                    int slope2 = (third[1] - second[1]) * (second[0] - first[0]);
                    if (slope1 == slope2) {
                        count++;
                    }
                }
                res = Math.max(res, count);
            }
        }
        return res;
    }
}

 

优化的思路如下，还是需要看一下每两个点之间的直线的斜率。我们需要一个 hashset 排除重复的点，对于每一个点而言，我们还需要一个 hashmap<斜率，次数> 记录每个穿过当前点的直线的斜率分别出现了几次。与其是找出所有的直线并求斜率，这个思路的做法其实找的是全局范围内的 unique 的斜率值，然后看哪个斜率值出现的次数最多。

时间O(n^2)

空间O(n)

Java实现

class Solution {
    public int maxPoints(int[][] points) {
        int len = points.length;
        // corner case
        if (len < 2) {
            return len;
        }
        
        // normal case
        HashSet<String> set = new HashSet<>();
        int res = 1;
        // for循环遍历的是第一个点
        for (int i = 0; i < len && !set.contains(points[i][0] + "-" + points[i][1]); i++) {
            int[] a = points[i];
            // 和当前点一样的点有多少
            int same = 0;
            HashMap<Double, Integer> map = new HashMap<>();
            int max = 1;
            for (int j = i + 1; j < len; j++) {
                if (isSame(a, points[j])) {
                    same++;
                }
                // 穿过当前点的直线的斜率
                double slope = getSlope(a, points[j]);
                map.put(slope, map.getOrDefault(slope, 1) + 1);
                max = Math.max(max, map.get(slope));
            }
            // 记录当前点，这样以后即使遇到重复的点，也不会把他作为第一个点再扫描
            set.add(a[0] + "-" + a[1]);
            res = Math.max(res, max + same);
        }
        return res;
    }
    
    private boolean isSame(int[] a, int[] b) {
        return a[0] == b[0] && a[1] == b[1];
    }
    
    private double getSlope(int[] a, int[] b) {
        if (a[0] == b[0]) return Double.MAX_VALUE;
        if (a[1] == b[1]) return 0;
        return ((double) b[0] - a[0]) / ((double) b[1] - a[1]);
    }
}

 

LeetCode 题目总结