Осенева Валерия 8306

binary-search-for-the-answer/BinarySearchForTheAnswer.java

@@ -0,0 +1,47 @@
+import java.util.Scanner;
+import java.util.stream.IntStream;
+
+public class BinarySearchForTheAnswer {
+    private int[] array;
+
+    public static void main(String[] args) {
+        BinarySearchForTheAnswer search = new BinarySearchForTheAnswer();
+        Scanner scanner = new Scanner(System.in);
+
+        int N = Integer.parseInt(scanner.nextLine());
+        int K = Integer.parseInt(scanner.nextLine());
+
+        search.array = new int[N];
+        IntStream.range(0, K).forEach(i -> search.array[i] = Integer.parseInt(scanner.nextLine()));
+        System.out.println(search.solve(K));
+    }
+
+    private boolean check(int x, int k) {
+
+        int lines = 1;
+        int last = array[0];
+
+        for (int j : array) {
+            if (j - last >= x) {
+                lines++;
+                last = j;
+            }
+        }
+        return lines > k;
+    }
+
+    public int solve(int k) {
+        int left = 0;
+        int right = (array[array.length-1] - array[0]) + 1;
+        while (right - left > 1) {
+            int mid = (left + right) / 2;
+            if(check(mid, k)) {
+                left = mid;
+            } else {
+                right = mid;
+            }
+        }
+        return left;
+    }
+
+}

binary-search/BinarySearch.java

@@ -0,0 +1,51 @@
+import java.util.Scanner;
+
+public class BinarySearch {
+
+    private int[] array;
+
+
+    public static void main(String[] args) {
+
+        BinarySearch search = new BinarySearch();
+        Scanner scanner = new Scanner(System.in);
+
+        int N = Integer.parseInt(scanner.nextLine());
+        String[] inputArray = (scanner.nextLine()).split(" ");
+
+        search.array = new int[N];
+        for (int i = 0; i < N; i++) {
+            search.array[i] = Integer.parseInt(inputArray[i]);
+        }
+
+        int K = Integer.parseInt(scanner.nextLine());
+        for (int i = 0; i < K; i++) {
+            System.out.println(search.binSearch(Integer.parseInt(scanner.nextLine())));
+        }
+
+    }
+
+    public int binSearch(int number) {
+
+        int left = 0;
+        int right = array.length - 1;
+        int middle;
+
+        while (true) {
+
+            if (left > right)
+                return -1;
+
+            middle = (left + right) / 2;
+            if (array[middle] == number)
+                return middle;
+
+            if (array[middle] > number) {
+                right = middle - 1;
+            } else {
+                left = middle + 1;
+            }
+
+        }
+    }
+}

priority-queue/PriorityQueue.java

@@ -0,0 +1,84 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Scanner;
+
+public class PriorityQueue {
+    private ArrayList<Integer> arrayForQueue;
+
+    public static void main(String[] args) {
+
+        Scanner scanner = new Scanner(System.in);
+        PriorityQueue binaryHeap = new PriorityQueue();
+        binaryHeap.arrayForQueue = new ArrayList<>();
+
+        int N = Integer.parseInt(scanner.nextLine());
+
+        for (int i = 0; i < N; i++) {
+
+            String line = scanner.nextLine();
+
+            if (line.equals("GET")) {
+                System.out.println(binaryHeap.getMax());
+            } else {
+                binaryHeap.insert(Integer.parseInt(line));
+            }
+
+        }
+
+    }
+
+    private void down(int i) {
+
+        while (2 * i + 1 < arrayForQueue.size()) {
+
+            int left  = 2 * i + 1;
+            int right = 2 * i + 2;
+            int j = left;
+
+            if (right < arrayForQueue.size() && arrayForQueue.get(right) > arrayForQueue.get(left))
+                j = right;
+
+            if (arrayForQueue.get(i) >= arrayForQueue.get(j))
+                break;
+
+            Collections.swap(arrayForQueue, i, j);
+
+            i = j;
+
+        }
+    }
+
+    private void up(int i) {
+
+        while (arrayForQueue.get(i) > arrayForQueue.get((i - 1) / 2) && i > 0) {
+
+            Collections.swap(arrayForQueue, i, (i - 1) / 2);
+            i = (i - 1) / 2;
+
+        }
+    }
+
+    private int getMax() {
+
+        int max = arrayForQueue.get(0);
+        if (arrayForQueue.size() > 1) {
+            arrayForQueue.set(0, arrayForQueue.get(arrayForQueue.size() - 1));
+            arrayForQueue.remove(arrayForQueue.size() - 1);
+            down(0);
+        } else
+            arrayForQueue.remove(0);
+
+        return max;
+
+    }
+
+    private void insert(int key) {
+
+        if (arrayForQueue.size() > 0) {
+            arrayForQueue.add(key);
+            up(arrayForQueue.size() - 1);
+        } else
+            arrayForQueue.add(key);
+    }
+
+}

union-find-forest/UFForest.java

@@ -0,0 +1,62 @@
+import java.util.Scanner;
+
+public class UFForest {
+
+    private int[] array;
+    private int[] rank;
+
+    public static void main(String[] args) {
+
+        UFForest unionFindForest = new UFForest();
+        Scanner scanner = new Scanner(System.in);
+        String[] input= scanner.nextLine().split(" ");
+
+        int N = Integer.parseInt(input[0]);
+        int K = Integer.parseInt(input[1]);
+
+        unionFindForest.array = new int[N];
+        unionFindForest.rank  = new int[N];
+
+        for (int i = 0; i < N; i++){
+            unionFindForest.rank[i]  = 1;
+            unionFindForest.array[i] = i;
+        }
+
+        for (int i = 0; i < K; i++){
+            input = scanner.nextLine().split(" ");
+            System.out.println(unionFindForest.union(Integer.parseInt(input[0]), Integer.parseInt(input[1])));
+        }
+    }
+
+    public int find(int x) {
+
+        if (x == array[x]){
+            return x;
+        }
+        else{
+            return (array[x] = find(array[x]));
+        }
+
+    }
+
+    public String union (int x, int y){
+
+        int X;
+        int Y;
+
+        if ((X = find(x)) == (Y = find(y)))
+            return "YES";
+
+        if (rank[X] < rank[Y])
+            array[X] = Y;
+        else{
+            array[Y] = X;
+
+            if (rank[X] == rank[Y])
+                ++rank[X];
+        }
+
+        return "NO";
+    }
+
+}