LeetCode:Max Points on a Line (Java)

题目：

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.

思路：

其实没有特别的东西，想法很直接，就是从第一个点开始，算出与其他点的斜率，斜率相同认为是同一直线。特别要注意与x周和y周垂直的情况，以及重叠的点。

代码：

代码非常烂

/**
 * Definition for a point.
 * class Point {
 *     int x;
 *     int y;
 *     Point() { x = 0; y = 0; }
 *     Point(int a, int b) { x = a; y = b; }
 * }
 */
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
 
public class Solution {
Map<Point,Map<Float, Integer>> map = new HashMap<Point,Map<Float, Integer>>();
	Map<Point, Integer> overlapMap = new HashMap<Point, Integer>();
    public int maxPoints(Point[] points) {
        if(null == points || points.length == 0) return 0;
        
        Arrays.sort(points,new PointComparator());			
        int overlapNum = 0;
        for(int i=1;i<points.length;i++) {
        	if(points[i].x==points[i-1].x && points[i].y==points[i-1].y)
        		overlapNum++;
        }
        Point[] noOverlapPoints = new Point[points.length-overlapNum];
        noOverlapPoints[0] = points[0];
        for(int i=1,j=1;i<points.length;i++) {
        	if(points[i].x==points[i-1].x && points[i].y==points[i-1].y) {
        		if(null == overlapMap.get(noOverlapPoints[j-1])) {
        			overlapMap.put(noOverlapPoints[j-1], 1);
        		}else {
        			overlapMap.put(noOverlapPoints[j-1], overlapMap.get(noOverlapPoints[j-1]) + 1);
        		}
        		
        	} else {
	        	noOverlapPoints[j] = points[i];
	        	j++;
        	}
        }
        
        for(int i=0;i<noOverlapPoints.length;i++) {				
        	Point point = noOverlapPoints[i];
        	Map<Float,Integer> pointMap = new HashMap<Float,Integer>();
            for(int j=i+1;j<noOverlapPoints.length;j++) {
                float slope = getSlope(point, noOverlapPoints[j]);
                int increase = 1;
                if(null != overlapMap.get(noOverlapPoints[j]))
                	increase += overlapMap.get(noOverlapPoints[j]);
                if(null ==  pointMap.get(slope)) {
                	pointMap.put(slope,increase);
                } else {
                	pointMap.put(slope,pointMap.get(slope)+increase);
                }
            }
            map.put(point, pointMap);
        }
        
        int res = 1;								
        Collection<Point> pointKey = map.keySet();
        for(Point point : pointKey) {
        	Integer overlapInteger = overlapMap.get(point);
        	int overlap = null == overlapInteger ? 0 : overlapInteger;
        	int curVal = 1 + overlap;
        	Collection<Integer> count = map.get(point).values();
        	if(count.size() > 0) {
	        	for(int i : count) {
	        		if(res < curVal + i)
	        			res = curVal + i;
	        	}
        	} else {
        		if(res < curVal)
        			res = curVal;
        	}
        }
        return res;
    }
    
    private float getSlope(Point a, Point b) {
        float slope = (float)(a.y - b.y) / (float)(a.x - b.x);
    	if(Float.isInfinite(slope))
    		slope = Float.POSITIVE_INFINITY;
    	return slope;
    }
    
    private class PointComparator implements Comparator<Point> {
		public int compare(Point o1, Point o2) {
			if(o1.x == o2.x && o1.y == o2.y)
				return 0;
			if(o1.x >= o2.x)
				return 1;
			else 
				return -1;
		}
    }
}