diff --git a/divideconquer/SkylineAlgorithm.java b/divideconquer/SkylineAlgorithm.java new file mode 100644 index 000000000..a1d4918ce --- /dev/null +++ b/divideconquer/SkylineAlgorithm.java @@ -0,0 +1,241 @@ + +package skylinealgorithm; + +import java.io.File; +import java.io.FileNotFoundException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.Scanner; + +/** + * + * @author Dimitrios Panagiotis Grigoriou / dimgrichr + * + * Space complexity: O(n) + * Time complexity: O(nlogn), because it is a divide and conquer algorithm + */ +public class SkylineAlgorithm { + private Scanner scanner; + private File file; + private ArrayList points; + private int tableSize; + + + /** + * Main constructor of the application. + * ArrayList points gets created, which represents the sum of all edges, + * which are read from input file. + * File's(built-in class) object file is created, + * and gets combined with Scanner's(built-in class) object scanner, + * so that the points are read. + * @param name , the name of the input file. + * @throws FileNotFoundException , if input file is not found. + */ + public SkylineAlgorithm(String name) throws FileNotFoundException{ + File file = new File(name); + scanner = new Scanner(file); + points = new ArrayList<>(); + tableSize=scanner.nextInt(); + } + + + /** + * ArrayList points is filled with all points that are included + * in the input file. + * Points are sorted based on the x-value, using a Comparator. + * @see XComparator + */ + public void fillMass(){ + for(int i=0;scanner.hasNextInt();i++){ + //points get added to the ArrayList + points.add(new Point(scanner.nextInt(),scanner.nextInt())); + } + //ArrayList points gets sorted + Collections.sort(points,new XComparator()); + } + + + /** + * @return points, the ArrayList that includes all points. + */ + public ArrayList 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 produceSubSkyLines(ArrayList 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 leftHalf=new ArrayList<>(); + ArrayList rightHalf=new ArrayList<>(); + for (int i=0;i leftSubSkyLine=new ArrayList<>(); + ArrayList rightSubSkyLine=new ArrayList<>(); + leftSubSkyLine=produceSubSkyLines(leftHalf); + 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 produceFinalSkyLine(ArrayList left, ArrayList right){ + + //dominated points of ArrayList left are removed + for(int i=0;ileft.get(i+1).y){ + left.remove(i); + i--; + } + } + + //minimum y-value is found + int min=left.get(0).y; + for(int i=1;ileft.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=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 + if((this.x { + @Override + public int compare(Point a, Point b) { + return a.x < b.x ? -1 : a.x == b.x ? 0 : 1; + } + } + + + //main function + public static void main(String[] args) throws FileNotFoundException { + if (args.length != 1) + { + System.out.println("Insert the input file"); + return; + } + SkylineAlgorithm skyline = new SkylineAlgorithm(args[0]); + skyline.fillMass(); + ArrayList list = skyline.produceSubSkyLines(skyline.getPoints()); + for(Point x: list){ + System.out.println(x.getX() + " " + x.getY()); + } + } +}