LeetCode 149. Max Points on a Line

原题链接在这里：https://leetcode.com/problems/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

NOTE: input types have been changed on April 15, 2019. Please reset to default code definition to get new method signature.

题解：

Given a 2D board, return the maximum points on the same line.

From each point i, get the slope from this point i and connecting all other points.

If slop are equal from 2 other points and of cource line goes through the current point i, then 3 points fall on the same line.

If coordinates are equal, they would be treated as 2 different point.  

Then for each point i, we have a HashMap<String, Integer> to accumlate mutiplicity of nodes on the same line.

Key String is dx + "," + dy representing slope. Of cource dx and dy are already divided by greatest common divisor.

Then the max points count from the current point i, would be max(multiplicity) + dup.

Time Complexity is O(n^2). n = points.length.

Space is O(n). 

AC Java:

class Solution {
    public int maxPoints(int[][] points) {
        if(points == null){
            return 0;
        }
        
        int n = points.length;
        if(n <= 2){
            return n;
        }
        
        int res = 0;
        
        for(int i = 0; i < n; i++){
            HashMap<String, Integer> countMap = new HashMap<>();
            int dup = 1;
            int maxFromThisPoint = 0;
            
            for(int j = i + 1; j < n; j++){
                int dx = points[j][0] - points[i][0];
                int dy = points[j][1] - points[i][1];
                if(dx == 0 && dy == 0){
                    dup++;
                    continue;
                }
                
                int gcd = getGcd(dx, dy);
                dx /= gcd;
                dy /= gcd;
                String key = dx + "," + dy;
                countMap.put(key, countMap.getOrDefault(key, 0) + 1);
                maxFromThisPoint = Math.max(maxFromThisPoint, countMap.get(key));
            }
            
            res = Math.max(res, maxFromThisPoint + dup);
        }
        
        return res;
    }
    
    private int getGcd(int x, int y){
        if(y == 0){
            return x;
        }
        
        return getGcd(y, x % y);
    }
}