[leetcode]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

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

 

题意：

给定二维平面上一些点，问最多多少个点共线

 

Solution1: HashMap

解本题需要的背景知识：【Math Fact】All the points in a line share the same slop.

                                   

The question is like standing at points[i],  find max number of points in points[j], such that points[i] and points[j] are on the same line.

1. If points[i], points[j] 's coordinator are the same, they are overlapping.

2. Otherwise, they are nonoverlapping. Based on the fact that "All the points in a line share the same slop", we use the greatest common divisor(最大公约数) to get the lowest term(最简化) for points[i], points[j]'s coordinator.  即[2,4] 和[4,8]， 我们用求最大公约数的方式，将其斜率化成最简形式： 1/2 和 1/2 

3. We use Map<x, Map<y, occurance>> map to get such slop from x and y's occurance. Then we know how many non-overlapping points in such line.

 

 

code

public class MaxPointsonaLine {
    // 已经给定的Point class
    class Point {
        int x;
        int y;

        Point() {
            x = 0;
            y = 0;
        }

        Point(int a, int b) {
            x = a;
            y = b;
        }
    }

    public int maxPoints(Point[] points) {
        int result = 0;
        Map<Integer, Map<Integer, Integer>> map = new HashMap<>();
        // standing at points[i]
        for (int i = 0; i < points.length; i++) {
            map.clear();
            int overlapping = 0;
            int nonoverlapping = 0;
            // checking points[j] 
            for (int j = i + 1; j < points.length; j++) {
                int x = points[j].x - points[i].x;
                int y = points[j].y - points[i].y;
                if (x == 0 && y == 0) {
                    overlapping++;
                    continue;
                }
                int gcd = generateGCD(x, y);
                if (gcd != 0) {
                    x = x / gcd;
                    y = y / gcd;
                }
                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 {
                    Map<Integer, Integer> m = new HashMap<>();
                    m.put(y, 1);
                    map.put(x, m);
                }
                overlapping = Math.max(nonoverlapping, map.get(x).get(y));
            }
            result = Math.max(result, overlapping + nonoverlapping + 1);
        }
        return result;
    }

    public int generateGCD(int a, int b) {
        return (b == 0) ? a : generateGCD(b, a % b);
    }
}