[CC150] Find a line passing the most number of points

Problem: Given a two-dimensional graph with points on it, find a line which passes the most number of points.

此题是Cracking the code 5th edition 第七章第六题，思路就是 n choose 2, 所以时间复杂度是O(n^2)，因为没有更快的办法。

此题的难点在于两点一线计算出的斜率是浮点型，不好比较equality。所以其中需要有一个精确到哪一位的概念，英文是 round to a given place value.

我认为此题书中给的解法特别傻逼，而且时间复杂度也超出了O(n^2)，故自己写了一个更好的版本。

另，关于使用自定义类用作HashMap的键值，如何重写equals()和hashCode()，下面的代码给出的很好的示范。

package chapter7;



import java.util.HashMap;



// given a two-dimensional graph with points on it,

// find a line which passes the most number of points

// Time: O(N^2), N is number of points



// The tricky part is checking the equality of slope

// which is of type double.

// My solution is floor all values to an epsilon value

// which specifies the desired precision



public class P6 {

	

	public Line findBestLine(GraphPoint[] points){

		Line bestLine = null;

		int bestCount = 0;

		HashMap<Line, Integer> lineCounts = 

				new HashMap<Line, Integer>();

		

		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]);

				int currentCount;

				

				if(lineCounts.containsKey(line)){

					currentCount = lineCounts.get(line) + 1;

				}else{

					currentCount = 1;

				}

				lineCounts.put(line, currentCount);

				

				if(currentCount > bestCount){

					bestCount = currentCount;

					bestLine = line;

				}

			}

		}

		

		return bestLine;

	}

}





class Line{

	// for precision 

	// slope and intercept values are floored to epsilon

	public static double epsilon = .0001;

	

	// properties for a normal line

	public double slope;

	public double y_intercept;

	

	// properties for a verticle line

	public boolean infinite_slope = false;

	public double x_intercept;

	

	public Line(GraphPoint p1, GraphPoint p2){

		

		if(p1.x == p2.x){

			this.infinite_slope = true;

			this.x_intercept = p1.x;

			

		}else{

			this.slope = (p1.y - p2.y) / (p1.x - p2.x);

			this.y_intercept = p1.y - slope * p1.x;

		

		}

		

		// floor all properties

		this.slope = floor(this.slope);

		this.x_intercept = floor(this.x_intercept);

		this.y_intercept = floor(this.y_intercept);

	}



	public double floor(double val){

		int val2 = (int)(val / epsilon);

		return val2 * epsilon;

	}

	

	@Override

	public int hashCode(){

		if(infinite_slope){

			return (int) x_intercept;

		}else{

			return (int) (slope + y_intercept);

		}

	}

	

	@Override

	public boolean equals(Object obj){

		if(this == obj)

			return true;

		if(obj == null)

			return false;

		if(getClass() != obj.getClass())

			return false;

		

		Line other = (Line)obj;

		

		if(infinite_slope && other.infinite_slope){ // both true

			return x_intercept == other.x_intercept;

			

		}else if(infinite_slope || other.infinite_slope){ // one true, one false

			return false;

		}

		else{ // both false

			return slope == other.slope && y_intercept == other.y_intercept;

		}

	}

}





class GraphPoint{

	// assume that x and y are both floored

	// to some point

	public double x;

	public double y;

}