186 lines
6.0 KiB
Java
186 lines
6.0 KiB
Java
import java.util.ArrayList;
|
|
import java.util.Comparator;
|
|
|
|
/**
|
|
* @author dimgrichr
|
|
* <p>
|
|
* Space complexity: O(n)
|
|
* Time complexity: O(nlogn), because it is a divide and conquer algorithm
|
|
*/
|
|
public class SkylineAlgorithm {
|
|
private ArrayList<Point> points;
|
|
|
|
/**
|
|
* Main constructor of the application.
|
|
* ArrayList points gets created, which represents the sum of all edges.
|
|
*/
|
|
public SkylineAlgorithm() {
|
|
points = new ArrayList<>();
|
|
}
|
|
|
|
|
|
/**
|
|
* @return points, the ArrayList that includes all points.
|
|
*/
|
|
public ArrayList<Point> getPoints() {
|
|
return points;
|
|
}
|
|
|
|
|
|
/**
|
|
* The main divide and conquer, and also recursive algorithm.
|
|
* It gets an ArrayList full of points as an argument.
|
|
* If the size of that ArrayList is 1 or 2,
|
|
* the ArrayList is returned as it is, or with one less point
|
|
* (if the initial size is 2 and one of it's points, is dominated by the other one).
|
|
* On the other hand, if the ArrayList's size is bigger than 2,
|
|
* the function is called again, twice,
|
|
* with arguments the corresponding half of the initial ArrayList each time.
|
|
* Once the flashback has ended, the function produceFinalSkyLine gets called,
|
|
* in order to produce the final skyline, and return it.
|
|
*
|
|
* @param list, the initial list of points
|
|
* @return leftSkyLine, the combination of first half's and second half's skyline
|
|
* @see Point
|
|
* @see produceFinalSkyLine
|
|
*/
|
|
public ArrayList<Point> produceSubSkyLines(ArrayList<Point> list) {
|
|
|
|
// part where function exits flashback
|
|
int size = list.size();
|
|
if (size == 1) {
|
|
return list;
|
|
} else if (size == 2) {
|
|
if (list.get(0).dominates(list.get(1))) {
|
|
list.remove(1);
|
|
} else {
|
|
if (list.get(1).dominates(list.get(0))) {
|
|
list.remove(0);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
// recursive part of the function
|
|
ArrayList<Point> leftHalf = new ArrayList<>();
|
|
ArrayList<Point> rightHalf = new ArrayList<>();
|
|
for (int i = 0; i < list.size(); i++) {
|
|
if (i < list.size() / 2) {
|
|
leftHalf.add(list.get(i));
|
|
} else {
|
|
rightHalf.add(list.get(i));
|
|
}
|
|
}
|
|
ArrayList<Point> leftSubSkyLine = produceSubSkyLines(leftHalf);
|
|
ArrayList<Point> rightSubSkyLine= produceSubSkyLines(rightHalf);
|
|
|
|
// skyline is produced
|
|
return produceFinalSkyLine(leftSubSkyLine, rightSubSkyLine);
|
|
}
|
|
|
|
|
|
/**
|
|
* The first half's skyline gets cleared
|
|
* from some points that are not part of the final skyline
|
|
* (Points with same x-value and different y=values. The point with the smallest y-value is kept).
|
|
* Then, the minimum y-value of the points of first half's skyline is found.
|
|
* That helps us to clear the second half's skyline, because, the points
|
|
* of second half's skyline that have greater y-value of the minimum y-value that we found before,
|
|
* are dominated, so they are not part of the final skyline.
|
|
* Finally, the "cleaned" first half's and second half's skylines, are combined,
|
|
* producing the final skyline, which is returned.
|
|
*
|
|
* @param left the skyline of the left part of points
|
|
* @param right the skyline of the right part of points
|
|
* @return left the final skyline
|
|
*/
|
|
public ArrayList<Point> produceFinalSkyLine(ArrayList<Point> left, ArrayList<Point> right) {
|
|
|
|
// dominated points of ArrayList left are removed
|
|
for (int i = 0; i < left.size() - 1; i++) {
|
|
if (left.get(i).x == left.get(i + 1).x && left.get(i).y > left.get(i + 1).y) {
|
|
left.remove(i);
|
|
i--;
|
|
}
|
|
}
|
|
|
|
// minimum y-value is found
|
|
int min = left.get(0).y;
|
|
for (int i = 1; i < left.size(); i++) {
|
|
if (min > left.get(i).y) {
|
|
min = left.get(i).y;
|
|
if (min == 1) {
|
|
i = left.size();
|
|
}
|
|
}
|
|
}
|
|
|
|
// dominated points of ArrayList right are removed
|
|
for (int i = 0; i < right.size(); i++) {
|
|
if (right.get(i).y >= min) {
|
|
right.remove(i);
|
|
i--;
|
|
}
|
|
}
|
|
|
|
// final skyline found and returned
|
|
left.addAll(right);
|
|
return left;
|
|
}
|
|
|
|
|
|
public static class Point {
|
|
private int x;
|
|
private int y;
|
|
|
|
/**
|
|
* The main constructor of Point Class, used to represent the 2 Dimension points.
|
|
*
|
|
* @param x the point's x-value.
|
|
* @param y the point's y-value.
|
|
*/
|
|
public Point(int x, int y) {
|
|
this.x = x;
|
|
this.y = y;
|
|
}
|
|
|
|
/**
|
|
* @return x, the x-value
|
|
*/
|
|
public int getX() {
|
|
return x;
|
|
}
|
|
|
|
/**
|
|
* @return y, the y-value
|
|
*/
|
|
public int getY() {
|
|
return y;
|
|
}
|
|
|
|
/**
|
|
* Based on the skyline theory,
|
|
* it checks if the point that calls the function dominates the argument point.
|
|
*
|
|
* @param p1 the point that is compared
|
|
* @return true if the point wich calls the function dominates p1
|
|
* false otherwise.
|
|
*/
|
|
public boolean dominates(Point p1) {
|
|
// checks if p1 is dominated
|
|
return (this.x < p1.x && this.y <= p1.y) || (this.x <= p1.x && this.y < p1.y);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* It is used to compare the 2 Dimension points,
|
|
* based on their x-values, in order get sorted later.
|
|
*/
|
|
class XComparator implements Comparator<Point> {
|
|
@Override
|
|
public int compare(Point a, Point b) {
|
|
return Integer.compare(a.x, b.x);
|
|
}
|
|
}
|
|
}
|