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

/**
 * Definition for a point.
 * class Point {
 *     int x;
 *     int y;
 *     Point() { x = 0; y = 0; }
 *     Point(int a, int b) { x = a; y = b; }
 * }
 */
public class Solution {
    public int maxPoints(Point[] points) {
        if(points==null || points.length==0) {
            return 0;
        }
        // y1 = ax1 + b
        // y2 = ax2 + b
        // a = (y1-y2)/(x1-x2)
        // b =
        HashMap<Double, HashMap<Double, HashSet<Integer>>> count = new HashMap<Double, HashMap<Double, HashSet<Integer>>>();
        for(int i=0;i<points.length;i++) {
            Point p1 = points[i];
            double x1 = p1.x;
            double y1 = p1.y;
            for(int j=i+1;j<points.length;j++) {
                Point p2 = points[j];
                double x2 = p2.x;
                double y2 = p2.y;
                double a, b;
                if(x1==x2) {
                    a = Double.NaN;
                    b = -x1;
                } else {
                    a = (y1-y2)/(x1-x2);
                    b = y2 - x2 * (y1-y2)/(x1-x2);
                }
                HashMap<Double, HashSet<Integer>> map = count.get(a);
                if(map==null) {
                    map = new HashMap<Double, HashSet<Integer>>();
                    count.put(a, map);
                }
                HashSet<Integer> set = map.get(b);
                if(set==null) {
                    set = new HashSet<Integer>();
                    map.put(b, set);
                }
                set.add(i);
                set.add(j);
            }
        }
        int max = 1;
        for(Double k1 : count.keySet()) {
            for(Double k2 : count.get(k1).keySet()) {
                int c = count.get(k1).get(k2).size();
                if(c>max) {
                    max = c;
                }
            }
        }
        return max;
    }
}

===========

/**
 * Definition for a point.
 * class Point {
 *     int x;
 *     int y;
 *     Point() { x = 0; y = 0; }
 *     Point(int a, int b) { x = a; y = b; }
 * }
 */
public class Solution {
    public int maxPoints(Point[] points) {
        // y = ax + b, or x = b
       
        int max = 0;
        int res = 0;
        HashMap<Integer, HashMap<Integer, Integer>> map = new HashMap<>();
        for (int i = 0; i < points.length; i++) {
            Point p1 = points[i];
            int overlap = 1;
            max = 0;
            map.clear();
            for (int j = i + 1; j < points.length; j++) {
                Point p2 = points[j];
                int deltaX = p1.x - p2.x;
                int deltaY = p1.y - p2.y;
                if (deltaX == 0 && deltaY == 0) {
                    overlap++;
                    continue;
                }
                int gcd = getGCD(deltaX, deltaY);
                if (gcd != 0) {
                    deltaX /= gcd;
                    deltaY /= gcd;
                }
                if (map.containsKey(deltaX)) {
                    if (map.get(deltaX).containsKey(deltaY)) {
                        map.get(deltaX).put(deltaY, 1 + map.get(deltaX).get(deltaY));
                    } else {
                        map.get(deltaX).put(deltaY, 1);
                    }
                } else {
                    HashMap<Integer, Integer> tmp = new HashMap<Integer, Integer>();
                    tmp.put(deltaY, 1);
                    map.put(deltaX, tmp);
                }
                max = Math.max(max, map.get(deltaX).get(deltaY));
            }
            res = Math.max(res, max + overlap);
        }
        return res;
    }
   
    private int getGCD(int a, int b) {
        if (b == 0) return a;
        return getGCD(b, a%b);
    }
}