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()
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 inequals
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 thehashCode
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 thehashCode
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 JavaTM programming language.)
public boolean equals(Object obj)
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 returntrue
. - It is symmetric: for any non-null reference values
x
andy
,x.equals(y)
should returntrue
if and only ify.equals(x)
returnstrue
. - It is transitive: for any non-null reference values
x
,y
, andz
, ifx.equals(y)
returnstrue
andy.equals(z)
returnstrue
, thenx.equals(z)
should returntrue
. - It is consistent: for any non-null reference values
x
andy
, multiple invocations ofx.equals(y)
consistently returntrue
or consistently returnfalse
, provided no information used inequals
comparisons on the objects is modified. - For any non-null reference value
x
,x.equals(null)
should returnfalse
.
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.