149. Max Points on a Line [Hard]

苏微oa第三题，经典的图形hard题

这题思路上没有特别难，但实现很tricky：

1. 斜率的表示

斜率不能直接相除得到小数，会损失精度

选择用(dx,dy)的点对表示，且点对中的值需要约掉他们的最大公约数，计算最大公约数又要用辗转相除法的代码

2. 特殊情况的共线

三种：

（1）重合的点

        a和b重合，则一定共线，每一条经过某一点的线，其上的共线点都应该加上所有与它重合的点。

（2）水平方向共线(dy == 0) 或 垂直方向共线(dx == 0)

        这两种情况可以单独处理也可以不单独处理，0和任何数n的最大公约数算出来都是n，正常计算后水平方向共线的斜率点对为(1, 0)，垂直方向共线的斜率点对为(0, 1)，不影响在map中作为key成为唯一标识。

3. 斜率点对的数据结构

需要对一个点出发到其余各点的斜率计数，用到map，点对是map的key

HashMap中的key可以是任意类型，判断key相等是调用key的equals()方法，因此我们需要equals()方法能判断内容相等的类型，比如String和List。

典型不能作为key的类型是数组：

用arr.equals()，调用的是Obejct的equals()方法，不能比较数组内容相同。用Arrays类型重写的equals()方法可以判断数组内容相同，通过Arrays.equals(arr)调用，但是HashMap比较key的时候不会这么调用（一定要用数组类型也可以，那需要自定义重写hashCode()和equals()方法）。

/**
 * 从下标小的点开始，计算它和比它下标大的点的斜率，斜率相等的点共线
 * Runtime: 8 ms, faster than 75.31%
 * Memory Usage: 37.9 MB, less than 93.64%
 */
class Solution {
    
    public int maxPoints(int[][] points) {
        int len = points.length;
        if (len <= 2) { // no more than two points would always be on one line
            return len;
        }
        int max = 2;
        for (int i = 0; i < points.length - 2; i++) {
            HashMap<List, Integer> map = new HashMap(); // cannot use array as key in map, it would compare the addresses instead of the values
            int tempMax = 0, same = 1;
            for (int j = i + 1; j < points.length; j++) {
                int dx = points[i][0] - points[j][0], dy = points[i][1] - points[j][1];
                if (dx == 0 && dy == 0) {
                    same++;
                } else {
                    List<Integer> keyList = new ArrayList();
                    int gcd = gcd(dx, dy);
                    keyList.add(dx / gcd);
                    keyList.add(dy / gcd);
                    map.put(keyList, map.getOrDefault(keyList, 0) + 1);
                }
            }
            for (int value : map.values()) {
                tempMax = Math.max(tempMax, value);
            }
            max = Math.max(max, tempMax + same);
        }
        return max;
    }
    
    private int gcd(int m, int n) { // calculate the greatest common divisor of m and n
        return n == 0 ? m : gcd(n, m % n);
    }
    
}

/**
 * 这段和上一段的做法一样，但使用了可以替代上面的一些代码，做拓展参考：
 * 1. 将map的key变成了String类型，构造String代表斜率点对
 *（注意如果要数组转换为String，可以用Arrays.toString(arr)的方式，这样是数组内容的字符串形式；但如果arr.toString()，就会是[类型@哈希值]，因为后者是调用的Object类型的toString方法）
 * 2. 开头减少了length <= 2的判断，让代码更精简，但会让没必要的情况进入循环，增加不必要的消耗（虽然应该可以忽略不计）
 * Runtime: 17 ms, faster than 42.45%
 * Memory Usage: 39.2 MB, less than 43.72%
 * (事实证明字符串相加等操作比list的add和equals的操作慢很多)
 */
class Solution {
    
    public int maxPoints(int[][] points) {
        int max = 0;
        for (int i = 0; i < points.length; i++) {
            int tempMax = 0, same = 1;
            HashMap<String, Integer> map = new HashMap();
            for (int j = i + 1; j < points.length; j++) {
                int dx = points[j][0] - points[i][0], dy = points[j][1] - points[i][1];
                if (dx == 0 && dy == 0) {
                    same++;
                } else {
                    int gcd = gcd(dx, dy);
                    String key = dx / gcd + "," + dy / gcd; // 可以改成"int[] arr = new int[]{dx / gcd, dy / gcd}; String key = Arrays.toString(arr);"，就只要8ms
                    map.put(key, map.getOrDefault(key, 0) + 1);
                }
            }
            for (int value : map.values()) {
                tempMax = Math.max(tempMax, value);
            }
            max = Math.max(max, tempMax + same);
        }
        return max;
    }
    
    private int gcd(int m, int n) {
        return n == 0 ? m : gcd (n, m % n);
    }
    
}