Algorithm Part I:Programming Assignment(3)

最新推荐文章于 2022-03-30 01:20:20 发布

原创最新推荐文章于 2022-03-30 01:20:20 发布 · 4.9k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#coursera #algorithm

Coursera:Algorithms 专栏收录该内容

8 篇文章

订阅专栏

本文介绍了一种计算机视觉领域的模式识别问题，即从给定点集中识别出由四个或以上点构成的最大线段。文章提供了两种解决方案，一种是暴力检查每个四点组合的方法，其时间复杂度为O(N^4)，另一种是基于排序的快速算法，时间复杂度为O(N^2 log N)。

问题描述：

Programming Assignment 3: Pattern Recognition

Write a program to recognize line patterns in a given set of points.

Computer vision involves analyzing patterns in visual images and reconstructing the real-world objects that produced them. The process in often broken up into two phases: feature detection and pattern recognition. Feature detection involves selecting important features of the image; pattern recognition involves discovering patterns in the features. We will investigate a particularly clean pattern recognition problem involving points and line segments. This kind of pattern recognition arises in many other applications such as statistical data analysis.

The problem. Given a set of N distinct points in the plane, draw every (maximal) line segment that connects a subset of 4 or more of the points.

Point data type. Create an immutable data type Point that represents a point in the plane by implementing the following API:

public class Point implements Comparable<Point> {
   public final Comparator<Point> SLOPE_ORDER;        // compare points by slope to this point

   public Point(int x, int y)                         // construct the point (x, y)

   public   void draw()                               // draw this point
   public   void drawTo(Point that)                   // draw the line segment from this point to that point
   public String toString()                           // string representation

   public    int compareTo(Point that)                // is this point lexicographically smaller than that point?
   public double slopeTo(Point that)                  // the slope between this point and that point
}

To get started, use the data type Point.java , which implements the constructor and the draw() , drawTo() , and toString() methods. Your job is to add the following components.

The compareTo() method should compare points by their y-coordinates, breaking ties by their x-coordinates. Formally, the invoking point (x₀, y₀) is less than the argument point (x₁, y₁) if and only if eithery₀ < y₁ or if y₀ = y₁ and x₀ < x₁.
The slopeTo() method should return the slope between the invoking point (x₀, y₀) and the argument point (x₁, y₁), which is given by the formula (y₁ − y₀) / (x₁ − x₀). Treat the slope of a horizontal line segment as positive zero; treat the slope of a vertical line segment as positive infinity; treat the slope of a degenerate line segment (between a point and itself) as negative infinity.
The SLOPE_ORDER comparator should compare points by the slopes they make with the invoking point (x₀, y₀). Formally, the point (x₁, y₁) is less than the point (x₂, y₂) if and only if the slope (y₁ − y₀) / (x₁ − x₀) is less than the slope (y₂ − y₀) / (x₂ − x₀). Treat horizontal, vertical, and degenerate line segments as in the slopeTo() method.

Brute force. Write a program Brute.java that examines 4 points at a time and checks whether they all lie on the same line segment, printing out any such line segments to standard output and drawing them using standard drawing. To check whether the 4 points p, q, r, and s are collinear, check whether the slopes between p and q, between p and r, and between p and s are all equal.

The order of growth of the running time of your program should be N⁴ in the worst case and it should use space proportional to N.

A faster, sorting-based solution. Remarkably, it is possible to solve the problem much faster than the brute-force solution described above. Given a point p, the following method determines whether pparticipates in a set of 4 or more collinear points.

Think of p as the origin.
For each other point q, determine the slope it makes with p.
Sort the points according to the slopes they makes with p.
Check if any 3 (or more) adjacent points in the sorted order have equal slopes with respect to p. If so, these points, together with p, are collinear.

Applying this method for each of the N points in turn yields an efficient algorithm to the problem. The algorithm solves the problem because points that have equal slopes with respect to p are collinear, and sorting brings such points together. The algorithm is fast because the bottleneck operation is sorting.

Write a program Fast.java that implements this algorithm. The order of growth of the running time of your program should be N² log N in the worst case and it should use space proportional to N.

APIs. Each program should take the name of an input file as a command-line argument, read the input file (in the format specified below), print to standard output the line segments discovered (in the format specified below), and draw to standard draw the line segments discovered (in the format specified below). Here are the APIs.

public class Brute {
   public static void main(String[] args)
}

public class Fast {
   public static void main(String[] args)
}

Input format. Read the points from an input file in the following format: An integer N, followed by N pairs of integers (x, y), each between 0 and 32,767. Below are two examples.

% more input6.txt       % more input8.txt
6                       8
19000  10000             10000      0
18000  10000                 0  10000
32000  10000              3000   7000
21000  10000              7000   3000
 1234   5678             20000  21000
14000  10000              3000   4000
                         14000  15000
                          6000   7000

Output format. Print to standard output the line segments that your program discovers, one per line. Print each line segment as an ordered sequence of its constituent points, separated by " -> ".

% java Brute input6.txt
(14000, 10000) -> (18000, 10000) -> (19000, 10000) -> (21000, 10000)
(14000, 10000) -> (18000, 10000) -> (19000, 10000) -> (32000, 10000)
(14000, 10000) -> (18000, 10000) -> (21000, 10000) -> (32000, 10000)
(14000, 10000) -> (19000, 10000) -> (21000, 10000) -> (32000, 10000)
(18000, 10000) -> (19000, 10000) -> (21000, 10000) -> (32000, 10000)

% java Brute input8.txt
(10000, 0) -> (7000, 3000) -> (3000, 7000) -> (0, 10000) 
(3000, 4000) -> (6000, 7000) -> (14000, 15000) -> (20000, 21000) 

% java Fast input6.txt
(14000, 10000) -> (18000, 10000) -> (19000, 10000) -> (21000, 10000) -> (32000, 10000) 

% java Fast input8.txt
(10000, 0) -> (7000, 3000) -> (3000, 7000) -> (0, 10000)
(3000, 4000) -> (6000, 7000) -> (14000, 15000) -> (20000, 21000)

Also, draw the points using draw() and draw the line segments using drawTo() . Your programs should call draw() once for each point in the input file and it should call drawTo() once for each line segment discovered. Before drawing, use StdDraw.setXscale(0, 32768) and StdDraw.setYscale(0, 32768) to rescale the coordinate system.

For full credit, do not print permutations of points on a line segment (e.g., if you output p→q→r→s, do not also output either s→r→q→p or p→r→q→s). Also, for full credit in Fast.java, do not print or plot subsegments of a line segment containing 5 or more points (e.g., if you output p→q→r→s→t, do not also output either p→q→s→t or q→r→s→t); you should print out such subsegments in Brute.java.

Deliverables. Submit only Brute.java, Fast.java, and Point.java. We will supply stdlib.jar and algs4.jar. Your may not call any library functions other than those in java.lang, java.util, stdlib.jar, and algs4.jar.

代码：

Point.java

import java.util.Comparator;

public class Point implements Comparable<Point> {

	public final Comparator<Point> SLOPE_ORDER = new PointCmp();

	private final int x; // x coordinate
	private final int y; // y coordinate

	public Point(int x, int y) {
		/* DO NOT MODIFY */
		this.x = x;
		this.y = y;
	}

	public void draw() {
		/* DO NOT MODIFY */
		StdDraw.point(x, y);
	}

	public void drawTo(Point that) {
		/* DO NOT MODIFY */
		StdDraw.line(this.x, this.y, that.x, that.y);
	}

	public double slopeTo(Point that) {
		/* YOUR CODE HERE */
		if (this.compareTo(that) == 0)
			return Double.POSITIVE_INFINITY*-1;
		else if (this.x == that.x)
			return Double.POSITIVE_INFINITY;
		else if (this.y == that.y)
			return +0;
		else
			return (that.y - this.y) * 1.0 / (that.x - this.x);
	}

	private class PointCmp implements Comparator<Point> {

		@Override
		public int compare(Point o1, Point o2) {
			// TODO Auto-generated method stub
			if (slopeTo(o1) < slopeTo(o2) || (slopeTo(o1) == slopeTo(o2) && o1.compareTo(o2) == -1))
				return -1;
			else if (slopeTo(o1) > slopeTo(o2) || (slopeTo(o1) == slopeTo(o2) && o1.compareTo(o2) == 1))
				return 1;
			else
				return 0;
		}

	}

	@Override
	public int compareTo(Point that) {
		// TODO Auto-generated method stub
		if (this.y < that.y || (this.y == that.y && this.x < that.x))
			return -1;
		else if (this.y == that.y && this.x == that.x)
			return 0;
		else
			return 1;
	}

	public String toString() {
		/* DO NOT MODIFY */
		return "(" + x + ", " + y + ")";
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		In in = new In(args[0]);
		int num = in.readInt();
		Point points[] = new Point[num];
		for (int i = 0; i < num; i++) {
			int x = in.readInt();
			int y = in.readInt();
			points[i] = new Point(x, y);
		}
		
		
	}

}

Brute.java

public class Brute {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StdDraw.setXscale(0, 32768);
		StdDraw.setYscale(0, 32768);

		In in = new In(args[0]);
		int num = in.readInt();
		Point points[] = new Point[num];
		for (int i = 0; i < num; i++) {
			int x = in.readInt();
			int y = in.readInt();
			points[i] = new Point(x, y);
			points[i].draw();
		}

		for (int i = 0; i < num; i++)
			for (int j = 0; j < num - i - 1; j++) {
				if (points[j].compareTo(points[j + 1]) == 1) {
					Point temp = points[j];
					points[j] = points[j + 1];
					points[j + 1] = temp;
				}
			}

		for (int i = 0; i < num; i++)
			for (int j = i + 1; j < num; j++)
				for (int k = j + 1; k < num; k++)
					for (int l = k + 1; l < num; l++) {
						if (points[i].slopeTo(points[j]) == points[j].slopeTo(points[k])
								&& points[j].slopeTo(points[k]) == points[k].slopeTo(points[l])) {
							StdOut.print(points[i].toString() + "->" + points[j].toString() + "->"
									+ points[k].toString() + "->" + points[l].toString() + "\n");
							points[i].drawTo(points[l]);
						}
					}
	}

}

Fast.java(不是所有的测试案例都能通过)

import java.util.Arrays;

public class Fast {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StdDraw.setXscale(0, 32768);
		StdDraw.setYscale(0, 32768);

		In in = new In(args[0]);
		int num = in.readInt();
		Point points[] = new Point[num];

		for (int i = 0; i < num; i++) {
			int x = in.readInt();
			int y = in.readInt();
			points[i] = new Point(x, y);
			points[i].draw();
		}

		for (int i = 0; i < num; i++)
			for (int j = 0; j < num - i - 1; j++) {
				if (points[j].compareTo(points[j + 1]) == 1) {
					Point temp = points[j];
					points[j] = points[j + 1];
					points[j + 1] = temp;
				}
			}

		// for(int i = 0;i < num;i++)
		// StdOut.print(points[i].toString()+"\n");

		for (int i = 0; i < num; i++) {
			Point temp[] = new Point[num];
			for (int j = 0; j < num; j++)
				temp[j] = points[j];
			Arrays.sort(temp, points[i].SLOPE_ORDER);
			// for(int j = 0;j < num;j++)
			// StdOut.print(temp[j].toString()+"\n");
			for (int j = 1; j < num - 2; j++) 
			{
				if (temp[0].compareTo(temp[j]) == -1 && temp[j].compareTo(temp[j + 1]) == -1
						&& temp[j + 1].compareTo(temp[j + 2]) == -1) 
				{
					int k = -1;
					if (temp[0].slopeTo(temp[j]) == temp[j].slopeTo(temp[j + 1])
							&& temp[j].slopeTo(temp[j + 1]) == temp[j + 1].slopeTo(temp[j + 2])) 
					{
							k = j + 2;
							while (temp[k].compareTo(temp[k + 1]) == -1 && (k + 1) < num && temp[k - 1].slopeTo(temp[k]) == temp[k].slopeTo(temp[k + 1]))
								k++;
					}
					if(k != -1)
					{
						StdOut.print(temp[0].toString() + "->");
						temp[0].drawTo(temp[j]);
					}
					
					while(j < k)
					{
						StdOut.print(temp[j].toString() + "->");
						temp[j].drawTo(temp[j+1]);
						j++;
					}
					if(k != -1)
						StdOut.print(temp[k].toString());
					StdOut.print("\n");
						
				}
			}
		}
	}
}