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

这道题第一次见到是在Cracking上面。第一次做的时候感觉自己的想法好复杂啊，然后看答案之后才豁然开朗。哎，还是菜。大概的思路是这样的。对于一条直线而言，在解析几何中有若干种表示方法，我记得中学学过3，4种吧。具体到这道题而言，斜截式无疑是最方便也最合适的表示方法了。也就是说，对于一条直线，用公式y=kx+b将其表示出来。那么，如果两条直线重合的话，它们的斜率k和截距b必须相等才行。给定两点，可以通过简单的数学推导求出它们所在直线的斜率和截距。沿着这个思路想下去，我们还需要一个HashMap用来存储已经遇到过的直线和其经过的点的个数。在我的程序里面，是这样定义的，HashMap<Line, ArrayList<Point>>。也就是说，每次根据两个点，计算得到一条直线，然后看其是否在HashMap之中，然后把原先没有的点补充到key里面，最后再用一个变量max来记录最大的点数，每次点有更新的时候，都看看是否需要更新max。这样做的时间复杂度是O(n2)。应该还会有更好的方法，等想出来或者查到了再更新吧。

还有三个问题值得注意。首先，因为斜率和截距是double类型的变量，所以在比较的时候，必须设定一个epsilon，如果两条直线的斜率和截距的差值均小于epsilon的话，它们才算重合。这是因为浮点数无法精确处理的原因。其次，如果直线垂直于X轴，那么其斜率将是无穷大。为了处理这种情况，我们可以在Line这个类中增加一个boolean属性，这个属性用于表示该直线是否垂直于X轴，然后在比较的时候稍加注意这个edge case便好。最后，必须要注意，为了使得HashMap正常工作，在Line这个类中，我们必须要重写equals和hashcode这两个方法。记住，这两个方法必须同时重写才行。简单的理解，hashcode用于从一个array中找到一个key对应的value应该被存放的位置。但是为了解决冲突的问题，array存的是链表而不是value，所以，可能还要继续按照链表往下找。所以说，equals的两个object必然有相同的hashcode，但是hashcode相同的两个object并不一定会是equals的关系。把javadoc里面关于Object类的hashcode和equals方法的描述贴到下面，以后忘了就看看。

代码如下：

/**
 * 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;
        if(points.length==1) return 1;
        
        HashMap<Line, ArrayList<Point>> map = new HashMap<Line, ArrayList<Point>>();
        int max = 0;
        for(int i=0; i<points.length; i++) {
            for(int j=i+1; j<points.length; j++) {
                Line line = new Line(points[i], points[j]);
                if(!map.containsKey(line)) {
                    map.put(line, new ArrayList<Point>());
                }
                if(!map.get(line).contains(points[i])) map.get(line).add(points[i]);
                if(!map.get(line).contains(points[j])) map.get(line).add(points[j]);
                if(map.get(line).size()>max) max=map.get(line).size();
            }
        }
        return max;
    }
}

class Line {
    public double slope;
    public double intersect;
    private static double epsilon = 0.0001;
    private boolean vertical = false;
    
    public Line(Point a, Point b) {
        if(Math.abs(a.x-b.x) < epsilon) {   // vertical line
            vertical = true;
            intersect = a.x;
        }
        else {  // non-vertical line
            slope = ((double)(a.y-b.y))/(a.x-b.x);
            intersect = ((double)(a.x*b.y-a.y*b.x))/(a.x-b.x);
        }
    }
    
    @Override
    public boolean equals(Object o) {
        Line l = (Line) o;
        if(isEqual(slope, l.slope) && isEqual(intersect, l.intersect) && vertical==l.vertical) {
            return true;
        }
        else {
            return false;
        }
    }
    
    @Override
    public int hashCode() {
        int sl = (int)(slope * 1000);
        int in = (int)(intersect * 1000);
        return sl | in;
    }
    
    public boolean isEqual(double a, double b) {
        return (Math.abs(a-b) < epsilon);
    }
}

public int hashCode()

Returns a hash code value for the object. This method is supported for the benefit of hash tables such as those provided by  HashMap.

The general contract of hashCode is:

• Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
• If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
• It is not required that if two objects are unequal according to the equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables.

As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the Java^TM programming language.)

public boolean equals(Object obj)

Indicates whether some other object is "equal to" this one.

The equals method implements an equivalence relation on non-null object references:

• It is reflexive: for any non-null reference value x, x.equals(x) should return true.
• It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
• It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
• It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
• For any non-null reference value x, x.equals(null) should return false.

The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).

Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.