LeetCode-Max Points on a Line[AC源码]

package com.lw.leet3;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;


/**
 * @ClassName:Solution
 * @Description: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.
 * @Author LiuWei
 * @Date 2014年8月17日下午2:51:08
 * @Mail nashiyue1314@163.com 
 */

/**
 * 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) {
        int max = 0;
        if(points.length <= 2){
            max = points.length;
        }
        else{
            for(int i = 0; i < points.length; i++){
                int equalNum = 0;
                Map<Double, Integer> map = new HashMap<Double, Integer>();
                for(int j = i+1; j < points.length; j++ ){
                    if(points[i].x == points[j].x && points[i].y == points[j].y){
                        equalNum ++;
                        continue;
                    }
                    
                    double k = 0;
                    if(points[i].x == points[j].x){
                        k = Double.MAX_VALUE;
                    }
                    else{
                        k = ((double)(points[i].y - points[j].y)/(points[i].x - points[j].x));
                        /**
                         * Submission Result: Wrong Answer
                         * Input:    [(2,3),(3,3),(-5,3)]
                         * Output:    2
                         * Expected:3
                         * 
                         * avoid k = +0.0 -0.0
                         * */
                        if(k == 0){
                            k = 0; 
                        }
                    }
                    
                    if(map.containsKey(k)){
                        map.put(k, map.get(k)+1);
                    }
                    else{
                        map.put(k, 2);
                    }
                }
                
                /**
                 * Submission Result: Wrong Answer
                 * Input:    [(1,1),(1,1),(1,1)]
                 * Output:    0
                 * Expected:3
                 * 
                 * avoid the points are all equal
                 * */
                if(equalNum > max){
                    max = equalNum + 1 ;
                }
                Iterator<Entry<Double, Integer>> iter = map.entrySet().iterator();
                while(iter.hasNext()){
                    Entry<Double, Integer> entry = iter.next();
                    int num = entry.getValue();
                    if( num + equalNum > max){
                        max = num + equalNum; 
                    }
                }
            }
        }
        return max;
    }
    
    public static void main(String[] args){
        Point[] p = {new Point(2, 3),new Point(3,3),new Point(-5,3)};
//        Point[] p = {new Point(1, 1),new Point(1,1),new Point(1,1)};
        
        Solution s = new Solution();
        System.out.println(s.maxPoints(p));
        
    }
    
}