Coursera普林斯顿算法课第三次作业

Point: 重点是Comparable和Comparator接口的区别和实现。另外需要特别注意点的坐标是整数类型而斜率是浮点数，所以在计算斜率时可以乘以1.0。其次要注意Java中正负零不相等的问题，即0/5与0/(-5)不相同。

import java.util.Comparator;
import edu.princeton.cs.algs4.StdDraw;

public class Point implements Comparable{
	
	private int x;
	private int y;

	public Point(int x, int y){
		this.x = x;
		this.y = y;
	}
	
	// x and y are between 0 and 32767
	public void draw(){
		StdDraw.point(x, y);
	}
	
	// StdDraw with input between 0 and 1
	public void drawTo(Point that){
		StdDraw.line(x, y, that.x, that.y);
	}
	
	public String toString() {
		return "Point [x=" + x + ", y=" + y + "]";
	}

	// implementation for Comparable
	public int compareTo(Point that) {
		if(y < that.y || (y == that.y && x < that.x)){
			return -1;
		}else if(y == that.y && x == that.x){
			return 0;
		}else{
			return 1;
		}	
	}
	
	public double slopeTo(Point that){
		if(this.compareTo(that) == 0){
			return Double.NEGATIVE_INFINITY;
		}else if(this.x == that.x){
			return Double.POSITIVE_INFINITY;
		}else if(this.y == that.y){
			return +0; // negative zero != positive zero
		}else{
			return (that.y - y) * 1.0 /(that.x - x); // integer to double
		}
	}
	
	public Comparator slopeOrder(){
		return new BySlope();
	}
	
	// implementation for Comparator
	private class BySlope implements Comparator{

		public int compare(Point o1, Point o2) {
			if(slopeTo(o1) < slopeTo(o2)) return -1;
			if(slopeTo(o1) > slopeTo(o2)) return 1;
			return 0;
		}	
	}

}

LineSegment：不做要求，测试时会提供。注意StdDraw的使用。

import edu.princeton.cs.algs4.StdDraw;

public class LineSegment {
	
	private Point p_top;
	private Point p_bot;
	
	public LineSegment(Point p, Point q){
		p_top = p;
		p_bot = q;
	}
	
	public void draw(){
		p_top.drawTo(p_bot);
	}

	public String toString() {
		return "LineSegment [p1=" + p_top + ", p2=" + p_bot + "]";
	}

	public static void main(String[] args){
		Point p1 = new Point(15000,18000);
		Point p2 = new Point(8000,22000);
		Point p3 = new Point(600,9000);
		Point p4 = new Point(9000,5000);
		Point p5 = new Point(12000,10000);
		
		StdDraw.enableDoubleBuffering();
		StdDraw.setXscale(0, 32768);
		StdDraw.setYscale(0, 32768);
		StdDraw.setPenRadius(0.01);
		StdDraw.setPenColor(StdDraw.BLUE);
		
		p1.draw();
		p2.draw();
		p3.draw();
		p4.draw();
		p5.draw();
		StdDraw.show();
		
		StdDraw.setPenColor(StdDraw.MAGENTA);
		p1.drawTo(p5);
		p2.drawTo(p4);
		StdDraw.setPenColor(StdDraw.RED);
		p3.drawTo(p2);
		StdDraw.show();
			
	}
}

BruteCollinearPoints：使用了ArrayList及其自带的toArray方法。时间复杂度控制在N^4以内。注意不能直接对构造方法输入参数points进行排序，需要进行深度复制。

import java.util.ArrayList;
import edu.princeton.cs.algs4.Merge;

public class BruteCollinearPoints {
	
	private Point[] pts;
	private ArrayList lines;
	
	public BruteCollinearPoints(Point[] points){
		// deep copy to avoid mutating the constructor argument
		checkNullArgument(points);
		this.pts = new Point[points.length]; 
		for(int k = 0; k < points.length; k++){
			pts[k] = points[k];
		}
		
		checkDuplicatedElement(pts); // mergesort
		lines = new ArrayList(); // to avoid NullPointerException
		
		for(int k1 = 0; k1 < pts.length; k1++){
			for(int k2 = k1 + 1; k2 < pts.length; k2++){
				for(int k3 = k2 + 1; k3 < pts.length; k3++){
					
					if(pts[k1].slopeTo(pts[k2]) == pts[k1].slopeTo(pts[k3])){
						for(int k4 = k3 + 1; k4 < pts.length; k4++){
							if(pts[k1].slopeTo(pts[k2]) == pts[k1].slopeTo(pts[k4])){
								// k1, k2, k3, k4 are already sorted
								lines.add(new LineSegment(pts[k1], pts[k4]));
							}
						}
					}
				}
			}
		}
	}
	
	public int numberOfSegments(){
		return lines.size();
	}
	
	// line segment will contain at most 4 collinear points
	public LineSegment[] segments(){
		
		return lines.toArray(new LineSegment[numberOfSegments()]);
	}
	
    private void checkDuplicatedElement(Point[] points){
		
		// sort input array by natural order
		Merge.sort(points);
		
		// duplicated element
		for(int i=1; i

FastCollinearPoints：难点在于如何确认找到的segment是不是之前找到过的线段的subsegment，同时要保证时间复杂度在N*N*lg(N)以内。以下代码通过使用复杂度为lg(N)的BinarySearch成功地完成了任务。

import java.util.ArrayList;
import java.util.Arrays;

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.Merge;
import edu.princeton.cs.algs4.StdDraw;
import edu.princeton.cs.algs4.StdOut;

public class FastCollinearPoints {
	
	private Point[] pts;
	private ArrayList lines;
	
	/**
	 * constructor ~ n*nlg(n)
	 * @param points
	 */
	public FastCollinearPoints(Point[] points){
		
		checkNullArgument(points);
		this.pts = new Point[points.length]; 
		for(int k = 0; k < points.length; k++){
			pts[k] = points[k];
		}
		
		checkDuplicatedElement(pts); // mergesort ~ nlg(n)
		lines = new ArrayList(); // to avoid NullPointerException
		
		// IndexOutOfBoundsException for i < pts.length
		for(int i = 0; i < pts.length - 1; i++){
			
			Double[] slopesB4 = new Double[i]; // slopes with points upstream
			Point[] pointsAf = new Point[pts.length - i - 1]; // points downstream
			
			for(int k = 0; k < i; k++) {
				slopesB4[k] = pts[i].slopeTo(pts[k]);
			}
			
			for(int j = 0; j < pts.length - i - 1; j++) { 
				pointsAf[j] = pts[j + i + 1]; 
			}
			
			// sort upstream slopes by natural order ~ nlg(n)
			Merge.sort(slopesB4); 
			
			// sort downstream points by slope order to pts[i] ~ nlg(n)
			Arrays.sort(pointsAf, pts[i].slopeOrder()); 
			
			addSegment(slopesB4, pts[i], pointsAf); // ~ nlg(n)
		}
	}
	
	/**
	 * add appropriate line segment ~ nlg(n)
	 * @param slopesB4: slopes of upstream points to point p
	 * @param p: the origin point
	 * @param pointsAf: downstream points
	 */
	private void addSegment(Double[] slopesB4, Point p, Point[] pointsAf){
		
		int count = 1;
		double lastSlope = p.slopeTo(pointsAf[0]);
		
		for(int i = 1; i < pointsAf.length; i++){
			double slope = p.slopeTo(pointsAf[i]);
			
			if(slope != lastSlope){
				if(count >= 3 && !subSegment(lastSlope, slopesB4)){
					lines.add(new LineSegment(p, pointsAf[i - 1]));
				}		
				count = 1;
			}else{
				count++; // the loop terminates with the last possible segment unchecked
			}
			
			lastSlope = slope;
		}
		
		// check the last point
		if(count >= 3 && !subSegment(lastSlope, slopesB4)){
			lines.add(new LineSegment(p, pointsAf[pointsAf.length - 1]));
		}
	}
	
	/**
	 * binary search the given slope in slopsB4 ~ lg(n)
	 * @param s: the given slope
	 * @param slopes: of upstream points to the origin point
	 * @return 
	 */
	private boolean subSegment(double s, Double[] slopes){
		
		int lo = 0;
		int hi = slopes.length - 1;
		
		while(lo <= hi){
			int mid = lo + (hi - lo) / 2;
			if(s < slopes[mid]) hi = mid - 1;
			else if(s > slopes[mid]) lo = mid + 1;	
			else return true;
		}
		
		return false;
	}
	
	public int numberOfSegments(){
		return lines.size();
	}
	
	public LineSegment[] segments(){
		
		return lines.toArray(new LineSegment[numberOfSegments()]);
	}
	
    private void checkDuplicatedElement(Point[] points){
		
		// sort input array by natural order
		Merge.sort(points);
		
		// duplicated element
		for(int i=1; i