nextcommit

Author: shashankch

src/revision/SumMinMaxSubarrK.java

@@ -0,0 +1,106 @@
+package revision;
+
+import java.util.Deque;
+import java.util.LinkedList;
+
+public class SumMinMaxSubarrK {
+
+    // method to find max in subarray of size K using deque in java
+
+    public static void maxsubk(int arr[], int k) {
+
+        int n = arr.length;
+
+        Deque<Integer> dq = new LinkedList<>();
+        int i;
+        for (i = 0; i < k; i++) {
+
+            while (!dq.isEmpty() && arr[i] >= arr[dq.peekLast()]) {
+                dq.removeLast();
+
+            }
+            dq.addLast(i);
+        }
+
+        for (; i < n; i++) {
+
+            System.out.println(arr[dq.peek()]);
+
+            while (!dq.isEmpty() && dq.peek() <= (i - k)) {
+                dq.removeFirst();
+            }
+
+            while (!dq.isEmpty() && arr[i] >= arr[dq.peekLast()]) {
+                dq.removeLast();
+
+            }
+            dq.addLast(i);
+
+        }
+
+
+        System.out.println(arr[dq.peek()]);
+
+
+
+    }
+
+    public static int sumMinMax(int arr[], int k) {
+
+        int n = arr.length;
+        int sum = 0;
+        Deque<Integer> asc = new LinkedList<>();
+        Deque<Integer> desc = new LinkedList<>();
+
+        int i;
+        for (i = 0; i < k; i++) {
+
+            while (!asc.isEmpty() && arr[asc.peekLast()] >= arr[i]) {
+                asc.removeLast();
+            }
+
+            while (!desc.isEmpty() && arr[desc.peekLast()] <= arr[i]) {
+                desc.removeLast();
+            }
+            desc.addLast(i);
+            asc.addLast(i);
+        }
+
+
+        for (; i < n; i++) {
+
+            sum += (arr[asc.peekFirst()] + arr[desc.peekFirst()]);
+
+            while (!asc.isEmpty() && asc.peek() <= (i - k)) {
+                asc.removeFirst();
+            }
+            while (!desc.isEmpty() && desc.peek() <= (i - k)) {
+                desc.removeFirst();
+            }
+
+
+            while (!asc.isEmpty() && arr[asc.peekLast()] >= arr[i]) {
+                asc.removeLast();
+            }
+
+            while (!desc.isEmpty() && arr[desc.peekLast()] <= arr[i]) {
+                desc.removeLast();
+            }
+            desc.addLast(i);
+            asc.addLast(i);
+
+        }
+
+        sum += (arr[asc.peekFirst()] + arr[desc.peekFirst()]);
+        return sum;
+
+    }
+
+
+    public static void main(String[] args) {
+
+        int arr[] = {2, 5, 6, 3, 5};
+        int k = 2;
+        System.out.println(sumMinMax(arr, k));
+    }
+}

src/revision/circularTour.java

@@ -0,0 +1,66 @@
+package revision;
+
+
+class PetrolPump {
+
+    int petrol;
+    int distance;
+
+    public PetrolPump(int petrol, int distance) {
+
+        this.petrol = petrol;
+        this.distance = distance;
+    }
+
+}
+
+
+public class circularTour {
+
+
+    // In this ques we are given pairs {petrol pump capacity,dist to next pump}
+    // find the index of pump from where truck can complete entire circle.
+    // pump are at dist in circular dist. and truck has infinite capacity.
+
+
+
+    public static int findstart(PetrolPump arr[]) {
+
+        int start = 0;
+        int end = 1;
+
+        int n = arr.length;
+        int currPetrol = arr[start].petrol - arr[start].distance;
+
+        while (end != start || currPetrol < 0) {
+
+
+            while (currPetrol < 0 && end != start) {
+
+                currPetrol -= arr[start].petrol - arr[start].distance;
+                start = (start + 1) % n;
+
+                if (start == 0) {
+                    return -1;
+                }
+
+            }
+
+            currPetrol += arr[end].petrol - arr[end].distance;
+            end = (end + 1) % n;
+
+
+        }
+
+        return start;
+
+    }
+
+    public static void main(String[] args) {
+
+        PetrolPump arr[] = {new PetrolPump(6, 4), new PetrolPump(3, 6), new PetrolPump(7, 3)};
+        System.out.println(findstart(arr));
+
+    }
+
+}