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

public class MaxPointsOnOneLine {
    public int maxPoints(int[][] points) {
        int res = 0;
        for(int i = 0; i < points.length; i++) {
            int dup = 0, max = 0;
            Map<String, Integer> map = new HashMap<>();

            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) {
                    dup++;
                    continue;
                }

                int div = gcd(dX, dY);
                String key = (dX/div)+","+(dY/div);

                map.put(key, map.getOrDefault(key, 0) + 1);
                max = Math.max(max, map.get(key));
            }
            res = Math.max(res, max + dup + 1);
        }
        return res;
    }

    int gcd(int a, int b) {
        if(a == 0) return b;
        return gcd(b%a, a);
    }

    public static void main(String[] args) {
        int[][] points = { {1,1}, {2,2}, {3,3} };
        System.out.println(new MaxPointsOnOneLine().maxPoints(points));
    }
}

 

public class MaxPointsOnOneLine {
    public int maxPoints(int[][] points) {
        if(points.length < 3) {
            return points.length;
        }

        if(points.length == 3 && isCollinear(points[0], points[1], points[2])){
            return 3;
        }

        int result = 0;
        for (int i = points.length - 1; i > 0; i -= 2) {
            int[] first = points[i];
            int[] second = points[i-1];
            int cnt = 2;
            boolean overlap = isOverlap(first, second);
            for(int j = 0;j < points.length;j++) {
                int[] third = points[j];
                boolean collinear = overlap ? isOverlap(first, third) : isCollinear(first, second, third);
                if(collinear) {
                    cnt++;
                }

                result = Math.max(result, cnt);
            }
        }
        return result;
    }



    private boolean isCollinear(int[] p1, int[] p2, int[] p3){
        //same points
        if(p1 == p3 || p2 == p3) return false;

        long x = (long)(p3[1] - p1[1]) * (p2[0] - p1[0]);
        long y = (long)(p2[1] - p1[1]) * (p3[0] - p1[0]);

        return x == y;
    }

    private boolean isOverlap(int[] p1, int[] p2){
        return p1[0] == p2[0] && p1[1] ==p2[1];
    }

    public static void main(String[] args) {
        int[][] points = { {1,1}, {2,2}, {3,3} };
        System.out.println(new MaxPointsOnOneLine().maxPoints(points));
    }
}