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

A better solution:

/**
 * Definition for a point.
 * class Point {
 *     int x;
 *     int y;
 *     Point() { x = 0; y = 0; }
 *     Point(int a, int b) { x = a; y = b; }
 * }
 */
class Line{    
    //a/b = (y1-y2)/(x1-x2), c/d=(x1y2-x2y1)/(x1-x2)
    int a, b, c, d;
    String uid;
    Set<Point> pList;
    public Line(Point p1, Point p2){
        pList = new HashSet<Point>();
        a = p1.y-p2.y;
        b = p1.x-p2.x;
        c = p1.x*p2.y-p2.x*p1.y;
        d = p1.x - p2.x;

        if (a==0){
            a = 0;
            b = 1;
            c = p1.y;
            d = 1;            
        } else if (b==0){
            a = 1;
            b = 0;
            c = p1.x;
            d = 1;
        } else {
            int gcd = getGCD(a,b);
            a = a/gcd;
            b = b/gcd;
            if (b<0 && a>0){
                a = -a;
                b = -b;
            }
            gcd = getGCD(c,d);
            c = c/gcd;
            d = d/gcd;
            if (d<0 && c>0){
                c = -c;
                d = -d;
            }
        }
        //generate uid
        setUID();
    }

    public void setUID(){
        uid = a + "/" + b + "/" + c + "/" + d;
    }

    public String getUID(){
        return uid;
    }

    private int getGCD(int x, int y){
        while (y!=0){
            int val = x % y;
            x = y;
            y = val;
        } 
        return x;
    }
}

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

        int res = 0;
        Map<Point,Integer> pMap = new HashMap<Point,Integer>();
        for (int i=0;i<points.length;i++)
            if (pMap.containsKey(points[i])){
                pMap.put(points[i],pMap.get(points[i])+1);
            } else {
                pMap.put(points[i],1);
            }

        Map<String,Line> lineMap = new HashMap<String,Line>();
        Iterator iter1 = pMap.entrySet().iterator();
        while (iter1.hasNext()){
            Map.Entry en1 = (Map.Entry) iter1.next();
            int val = (int) en1.getValue();
            if (res<val) res = val;
            Point p1 = (Point) en1.getKey();
            Map<Point,Integer> pMap2 = new HashMap<Point,Integer>();            
            pMap2.putAll(pMap);
            pMap2.remove(p1);            
            while (!pMap2.isEmpty()){
                Iterator iter2 = pMap2.entrySet().iterator();
                Map.Entry en2 = (Map.Entry) iter2.next();
                Point p2 = (Point) en2.getKey();
                Line l1 = new Line(p1,p2);
                String uid = l1.getUID();
                if (lineMap.containsKey(uid)){
                    Line l2 = lineMap.get(uid);
                    l2.pList.add(p1);
                    l2.pList.add(p2);
                    for (Point p: l2.pList) 
                        pMap2.remove(p);
                } else {
                    l1.pList.add(p1);
                    l1.pList.add(p2);
                    pMap2.remove(p2);
                    lineMap.put(l1.getUID(),l1);
                }
            }
        }

        iter1 = lineMap.entrySet().iterator();
        while (iter1.hasNext()){
            Map.Entry en = (Map.Entry) iter1.next();
            Line l1 = (Line) en.getValue();
            int pNum = 0;
            for (Point p: l1.pList)
                pNum += pMap.get(p);
            if (res<pNum) res = pNum;
        }
        return res;
    }
}

 

 

Solution:

/**
 * Definition for a point.
 * class Point {
 *     int x;
 *     int y;
 *     Point() { x = 0; y = 0; }
 *     Point(int a, int b) { x = a; y = b; }
 * }
 */

class Line {
    int slopeX;
    int slopeY;
    int b;
    boolean negSlope;
    boolean samePointLine;
    Set<Point> pointSet;
    String uid;
    public Line(int sx, int sy, int bb,boolean spl){
        if (sx<0) slopeX = -sx;
        else slopeX = sx;

        if (sy<0) slopeY = -sy;
        else slopeY = sy;

        if (sy==0) slopeX=1;
        if (sx==0) slopeY=1;
        b = bb;

        if (sx<0 || sy<0) negSlope = true;
        else negSlope = false;
        
        samePointLine = spl;

        pointSet = new HashSet<Point>();

        uid = Integer.toString(slopeX)+"/"+Integer.toString(slopeY)+"/"+Double.toString(b)+"/"+Boolean.toString(negSlope)+"/"+Boolean.toString(samePointLine);
  }

  public boolean equals(Line l2){
      if (uid==l2.uid)
          return true;
      else return false;
  }

}       


public class Solution {
    public int maxPoints(Point[] points) {
        if (points.length==1) return 1;
        
        Set<Point> pSet = new HashSet<Point>();
        for (int i=0;i<points.length;i++) pSet.add(points[i]);

        Map<String,Line> lineList = new HashMap<String,Line>();
        List<String> uidList = new ArrayList<String>();
        for (int i=1;i<points.length;i++){
            Set<Point> curPSet = new HashSet<Point>();
            curPSet.addAll(pSet);
            for (int j=0;j<i;j++)
                if (curPSet.contains(points[j])){
                //This point has not been checked.
                //Calculate the line formed by i and j
                    int ix = points[i].x;
                    int iy = points[i].y;
                    int jx = points[j].x;
                    int jy = points[j].y;
                    int sx = points[i].x-points[j].x;
                    int sy = points[i].y-points[j].y;
                    Line l1 = null;
                    //infnite slope line.
                    if (sx==0 && sy==0)
                        l1 = new Line(points[i].x,points[i].y,0,true);
                    else if (sx==0)
                        l1 = new Line(0,1,points[i].x,false);
                    else if (sy==0)
                        l1 = new Line(1,0,points[i].y,false);
                    else {
                        int bb = jy*ix-jx*iy;
                        int gcd = getGCD(sx,sy);
                        int gcd2 = getGCD(bb,sx);
                        sx = sx/gcd;
                        sy = sy/gcd;
                        bb = bb/gcd2;
                        l1 = new Line(sx,sy,bb,false);
                    }

                    //Check each exsiting line.
                    if (lineList.containsKey(l1.uid)){
                        lineList.get(l1.uid).pointSet.add(points[i]);
                        lineList.get(l1.uid).pointSet.add(points[j]);
                        curPSet.removeAll(lineList.get(l1.uid).pointSet);
                        
                    } else {                        
                        lineList.put(l1.uid,l1);
                        uidList.add(l1.uid);
                        l1.pointSet.add(points[i]);
                        l1.pointSet.add(points[j]);
                    }
               }
        }

        int max = 0;
        for (int i=0;i<uidList.size();i++)
            if (lineList.get(uidList.get(i)).pointSet.size()>max)
                max = lineList.get(uidList.get(i)).pointSet.size();

        return max;
        
    }


    public int getGCD(int a, int b){
        int left = a%b;
        while (left!=0){
            a=b;
            b=left;
            left=a%b;
        }
        return b;
    }


}