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 1:

Input: [[1,1],[2,2],[3,3]]
Output: 3
Explanation:
^
|
|        o
|     o
|  o  
+------------->
0  1  2  3  4

Example 2:

Input: [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
Output: 4
Explanation:
^
|
|  o
|     o        o
|        o
|  o        o
+------------------->
0  1  2  3  4  5  6

 [暴力解法]：

时间分析：

空间分析：

 [优化后]：

时间分析：

空间分析：

［奇葩输出条件］：

［奇葩corner case］：

数组为空时，特意指出是0个点

［思维问题］：

［英文数据结构或算法，为什么不用别的数据结构或算法］：

［一句话思路］：

分子分母同时约分掉gcd之后，用双重hashmap存储（x,(y,次数)）

［输入量］：空： 正常情况：特大：特小：程序里处理到的特殊情况：异常情况（不合法不合理的输入）：

［画图］：

［一刷］：

1. 有key必然有value，如果存在x的key就不用新建value了，不存在才要建
2. 每个点的duplicate也是独立的，出现在i的循环中

［二刷］：

［三刷］：

［四刷］：

［五刷］：

  [五分钟肉眼debug的结果]：

［总结］：

［复杂度］：Time complexity: O() Space complexity: O()

［算法思想：迭代/递归/分治/贪心］：

［关键模板化代码］：

最大公约数gcd，不等于0时才能除，位置要写对

public int getGcd(int a, int b) {
        //recursive
        if (b == 0) return a;
        //position is important
        else return getGcd(b, a % b);
    }

［其他解法］：

［Follow Up］：

［LC给出的题目变变变］：

 [代码风格] ：

 [是否头一次写此类driver funcion的代码] ：

 [潜台词] ：

/**
 * Definition for a point.
 * class Point {
 *     int x;
 *     int y;
 *     Point() { x = 0; y = 0; }
 *     Point(int a, int b) { x = a; y = b; }
 * }
 */
class Solution {
    public int maxPoints(Point[] points) {
        //ini
        int result = 0;
        //how to rewrite?
        HashMap<Integer, HashMap<Integer, Integer>> map = new HashMap<>();
        
        //cc: less than 2 points
        if (points == null) return 0;
        if (points.length <= 2) return points.length;
        
        //count every point
        for (int i = 0; i < points.length; i++) {
            int count = 0;
            int duplicate = 0;
            //clear previous data
            map.clear();
            
            //calculate x,y / gcd and the slope
            //cc : same slope
            for (int j = i + 1; j < points.length; j++) {
                int x = points[i].x - points[j].x;
                int y = points[i].y - points[j].y;
                int gcd = getGcd(x, y);
                //gcd musn't be 0
                if (gcd != 0) {
                    x /= gcd;
                    y /= gcd;
                }
                //x stands for the difference
                if (x == 0 && y == 0) {
                    duplicate++;
                    continue;
                }
                //map containsKey x or not, x contains y or not
                if (map.containsKey(x)) {
                    if (map.get(x).containsKey(y)) {
                        map.get(x).put(y, map.get(x).get(y) + 1);
                    }else {
                        map.get(x).put(y, 1);
                    }
                }else {
                    HashMap<Integer, Integer> m = new HashMap<Integer, Integer>();
                    m.put(y, 1);
                    map.put(x, m);
                }
                count = Math.max(map.get(x).get(y), count);
            }
            result = Math.max(result, count + duplicate + 1);
        }
        
        //return
        return result;
    }
    
    public int getGcd(int a, int b) {
        //recursive
        if (b == 0) return a;
        //position is important
        else return getGcd(b, a % b);
    }
}