149. 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.

Example

Given 4 points: (1,2), (3,6), (0,0), (1,3).

The maximum number is 3.

分析：http://blog.csdn.net/linhuanmars/article/details/21060933

这道题属于计算几何的题目，要求给定一个点集合，是求出最多点通过一条直线的数量。我的思路是n个点总共构成n*(n-1)/2条直线，然后对每条直线看看是有多少点在直线上，记录下最大的那个，最后返回结果。而判断一个点p_k在p_i, p_j构成的直线上的条件是(p_k.y-p_i.y)*(p_j.x-p_i.x)==(p_j.y-p_i.y)*(p_k.x-p_i.x)。算法总共是三层循环，时间复杂度是O(n^3),空间复杂度则是O(1),因为不需要额外空间做存储。

大家看到代码中还写了一个allSamePoints的函数，这是一个非常corner的情况，就是所有点都是一个点的情况，因为下面我们要跳过重复的点（否则两个重合点会认为任何点都在他们构成的直线上），但是偏偏当所有点都重合时，我们需要返回所有点。除了这种情况，只要有一个点不重合，我们就会从那个点得到结果，这是属于比较tricky的情况。

代码如下：

public class Solution {
    public int maxPoints(Point[] points) {
        if (points == null || points.length == 0) return 0;        
        if (allSamePoints(points))    return points.length;
        int max = 0;
        for (int i = 0; i < points.length - 1; i++) {
            for (int j = i + 1; j < points.length; j++) {
                if (points[j].y == points[i].y && points[j].x == points[i].x)
                    continue;
                int cur = 2;
                for (int k = 0; k < points.length; k++) {
                    if (k != i && k != j && (points[k].y - points[i].y)    * (points[j].x - points[i].x) == (points[j].y - points[i].y) * (points[k].x - points[i].x))
                        cur++;
                }
                max = Math.max(max, cur);
            }
        }
        return max;
    }

    private boolean allSamePoints(Point[] points) {
        for (int i = 1; i < points.length; i++) {
            if (points[0].y != points[i].y || points[0].x != points[i].x)
                return false;
        }
        return true;
    }
}

这道题还可以有另一种做法， 基本思路是这样的， 每次迭代以某一个点为基准， 看后面每一个点跟它构成的直线， 维护一个HashMap， key是跟这个点构成直线的斜率的值， 而value就是该斜率对应的点的数量， 计算它的斜率， 如果已经存在， 那么就多添加一个点， 否则创建新的key。 这里只需要考虑斜率而不用考虑截距是因为所有点都是对应于一个参考点构成的直线， 只要斜率相同就必然在同一直线上。 最后取map中最大的值， 就是通过这个点的所有直线上最多的点的数量。 对于每一个点都做一次这种计算， 并且后面的点不需要看扫描过的点的情况了， 因为如果这条直线是包含最多点的直线并且包含前面的点， 那么前面的点肯定统计过这条直线了。 因此算法总共需要两层循环， 外层进行点的迭代， 内层扫描剩下的点进行统计， 时间复杂度是O（n^2), 空间复杂度是哈希表的大小， 也就是O（n), 比起上一种做法用这里用哈希表空间省去了一个量级的时间复杂度。 代码如下：

public class Solution {
    public int maxPoints(int[][] points) {
        if (points.length <= 0)
            return 0;
        if (points.length <= 2)
            return points.length;
        int result = 0;
        for (int i = 0; i < points.length; i++) {
            HashMap<Double, Integer> hm = new HashMap<Double, Integer>();
            int samex = 1;
            int samep = 0;
            for (int j = 0; j < points.length; j++) {
                if (j != i) {
                    if ((points[j][0] == points[i][0]) && (points[j][1] == points[i][1])) {
                        samep++;
                    }
                    if (points[j][0] == points[i][0]) {
                        samex++;
                        continue;
                    }
                    double k = (double) (points[j][1] - points[i][1]) / (double) (points[j][0] - points[i][0]);
                    if (hm.containsKey(k)) {
                        hm.put(k, hm.get(k) + 1);
                    } else {
                        hm.put(k, 2);
                    }
                    result = Math.max(result, hm.get(k) + samep);
                }
            }
            result = Math.max(result, samex);
        }
        return result;
    }
}