Leetcode刷题149. 直线上最多的点数

给定一个二维平面，平面上有 n 个点，求最多有多少个点在同一条直线上。

示例 1:

输入: [[1,1],[2,2],[3,3]]
输出: 3
解释:
^
|
|        o
|     o
|  o  
+------------->
0  1  2  3  4
示例 2:

输入: [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
输出: 4
解释:
^
|
|  o
|     o        o
|        o
|  o        o
+------------------->
0  1  2  3  4  5  6

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

感谢windliang的详细解法，传送门 https://leetcode.wang/more.html

class Solution {
        public int maxPoints(int[][] points) {
//            return maxPointsI(points);
            
            //方法二：使用HashMap缓存
            //根据直线方程定义，我们知道一个点和一个斜率就可以唯一确定一条直线。
            //当确定一个点后，平面上的其他点都可以和这个点求出一个斜率，如果斜率相同，则说明点都在一条直线上。
            //此时我们可以定义hashmap，key为斜率，进行计数，也就是说保存经过某个点的直线，统计哪条直线上点最多。
            //但是斜率有可能是小数，所以使用分数来表示，求分子分母的最大公约数，然后约分，key可以定义为[分子+":"分母]
            //注意：有可能存在重复的点，需要额外定义变量记录，而且重复点肯定是经过当前点的直线。

            if (points == null) return 0;
            if (points.length < 3) return points.length;
            int res = 0;
            for (int i = 0; i < points.length; i++) {
                //记录重复的点
                int duplicate = 0;
                int max = 0;
                Map<String, Integer> map = new HashMap<>();
                for (int j = i + 1; j < points.length; j++) {
                    int dy = points[j][1] - points[i][1];
                    int dx = points[j][0] - points[i][0];
                    //记录重复的元素
                    if (dy == 0 && dx == 0) {
                        duplicate++;
                        continue;
                    }
                    //求分子分母的最大公约数，约分
                    int gcd = gcd(dx, dy);
                    //map的key等于 分子:分母
                    String key = dx/gcd + ":" + dy/gcd;
                    map.put(key, map.getOrDefault(key, 0) + 1);
                    max = Math.max(max, map.get(key));
                }
                //1代表当前点，duplicate代表和当前点重复的点
                res = Math.max(res, max + duplicate + 1);
            }
            return res;
        }

        private int maxPointsI(int[][] points) {
            //方法一：暴力解法
            //根据直线方程定义，两点确定一条直线，所以可以定义两个变量i,j，两层循环遍历所有可能存在的直线。
            //然后再定义变量k，循环判断其他点是否在之前两点组成的直线上。
            //1.假设两个点(x1,y1)、(x2,y2)组成一条直线，如何判断点(x,y)在其组成的直线上？
            //只要等式(y2-y1)/(x2-x1)=(y-y2)/(x-x2)成立即可。
            //但是如果使用除法，结果可能是小数，造成精度丢失，所以上面等式可以转换成(y2-y1)*(x-x2)=(y-y2)*(x2-x1)
            //注意如果乘积过大可能会溢出，所以需要使用long存储，但如果数据非常大，则可以考虑使用java提供的BigInteger类处理
            //其实可以考虑另外一种情况。
            //根据等式(y2-y1)/(x2-x1)=(y-y2)/(x-x2)发现，只要分数相等就可以，也就是说将两个分数约分到最简，然后判断分子分母相等就可以。
            //所以需要求分子与分母的最大公约数，使用辗转相除法。
            //这里需要注意的是我们求了(y-y2)/(x-x2)的最大公约数，我们需要保证两数都不等于0。
            //2.我们需要处理一些特殊情况，如果两个点相等，则可以直接跳过；同时需要考虑所有点都相等的情况，这样其实就是所有的点都在一条直线上。
            //3.另外，如果数组长度小于等于两个点，直接返回点的数量即可。

            if (points.length < 3) return points.length;
            //判断所有的点是否都相等
            int i = 0;
            for (; i < points.length - 1; i++) {
                //记录相等的点，遇到不相等的跳出循环
                if (points[i][0] != points[i + 1][0] || points[i][1] != points[i + 1][1])
                    break;
            }
            //如果相等的点 长度等于数组的长度，说明所有的点都在一条直线上，返回数组的长度
            if (i == points.length - 1) {
                return points.length;
            }
            //定义变量max，记录其他点是否在两点组成的直线上
            int max = 0;
            for (i = 0; i < points.length; i++) {
                for (int j = i + 1; j < points.length; j++) {
                    //跳过相等的点
                    if (points[i][0] == points[j][0] && points[i][1] == points[j][1]) continue;
                    //统计其他点 在两点组成的直线上
                    int temp = 0;
                    for (int k = 0; k < points.length; k++) {
                        //当前点不等于之前的两个点
                        if (k != i && k != j) {
                            //判断当前点是否在两点组成的直线上
                            boolean flag = isInLine(points[i][0], points[i][1], points[j][0], points[j][1], points[k][0], points[k][1]);
                            if (flag) {
                                temp++;
                            }
                        }
                    }
                    max = Math.max(temp, max);
                }
            }
            //返回在一条直线上的点数max + 2（加上直线上的两点）
            return max + 2;
        }

        //判断等式是否相等(y2-y1)/(x2-x1)=(y-y2)/(x-x2)
        //求分子分母的最大公约数，进行约分后，判读分数是否相等（分子和分母都相等）
        private boolean isInLine(int x1, int y1, int x2, int y2, int x, int y) {
            int g1 = gcd(y2 - y1, x2 - x1);
            if (y == y2 && x == x2) return true;
            int g2 = gcd(y - y2, x - x2);
            return (y2 - y1) / g1 == (y - y2) / g2 && (x2 - x1) / g1 == (x - x2) / g2;
        }

        //辗转相除法（递归法）
        //递归三要素
        //1.终止条件
        //2.调用单元
        //3.返回值
        private int gcd(int x, int y) {
            if (y == 0) return x;
            return gcd(y,  x % y);
        }
    }