update search in rotated sorted array

Author: anishLearnsToCode

src/BinarySearch.java

@@ -1,3 +1,7 @@
+// https://leetcode.com/problems/binary-search
+// T: O(logN)
+// S: O(1)
+
 public class BinarySearch {
     public int search(int[] array, int val) {
         int left = 0, right = array.length - 1, middle;

src/EdmondsKarp.java

@@ -0,0 +1,72 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class EdmondsKarp {
+    private static int[][] adj_matrix;
+
+    private static int edmonds_karp(int n, int source, int sink) {
+        int[] parent = initializeParent(n);
+        int max_flow = 0;
+
+        while (bfs(n, source, sink, parent)) {
+            int path_flow = Integer.MAX_VALUE;
+            int s = sink;
+            while (s != source) {
+                path_flow = Math.min(path_flow, adj_matrix[parent[s]][s]);
+                s = parent[s];
+            }
+            max_flow += path_flow;
+
+            int v = sink;
+            while (v != source) {
+                int u = parent[v];
+                adj_matrix[u][v] -= path_flow;
+                adj_matrix[v][u] += path_flow;
+                v = parent[v];
+            }
+
+            List<Integer> path = new ArrayList<>();
+            v = sink;
+            while (v != source) {
+                path.add(v);
+                v = parent[v];
+            }
+            path.add(source);
+            path = path.reversed();
+            System.out.println(path);
+
+            parent = initializeParent(n);
+        }
+
+        return max_flow;
+    }
+
+    private static int[] initializeParent(int n) {
+        final int[] result = new int[n];
+        Arrays.fill(result, -1);
+        return result;
+    }
+
+    private static boolean bfs(int n, int s, int t, int[] parent) {
+        final boolean[] visited = new boolean[n];
+        final Queue<Integer> queue = new LinkedList<>() {{ add(s); }};
+        visited[s] = true;
+
+        while (!queue.isEmpty()) {
+            int u = queue.poll();
+            for (int i = 0 ; i < n ; i++) {
+                final int value = adj_matrix[u][i];
+                if (!visited[i] && value > 0) {
+                    queue.add(i);
+                    visited[i] = true;
+                    parent[i] = u;
+                }
+            }
+        }
+
+        return visited[t];
+    }
+}

src/HelloWorld.java

@@ -1,32 +1,31 @@
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.PriorityQueue;
-import java.util.Queue;
-import java.util.Set;
-
 public class HelloWorld {
-    public List<List<Integer>> combinationSum(int[] candidates, int target) {
-        final Set<List<Integer>> result = new HashSet<>();
-        computeSums(candidates, target, result, 0, new ArrayList<>(), 0);
-        return new ArrayList<>(result);
+    public int search(int[] nums, int target) {
+        final int pivotIndex = binarySearchPivotIndex(nums);
+        final int answer = binarySearch(nums, 0, pivotIndex - 1, target);
+        if (answer != -1) {
+            return answer;
+        }
+        return binarySearch(nums, pivotIndex, nums.length - 1, target);
     }
 
-    private static void computeSums(int[] candidates, int target, Set<List<Integer>> result, int currentSum, List<Integer> current, int i) {
-        if (currentSum > target || i >= candidates.length) {
-            return;
-        }
-        if (currentSum == target) {
-            result.add(new ArrayList<>(current));
-            return;
+    private static int binarySearchPivotIndex(int[] array) {
+        int left = 0, right = array.length - 1, middle;
+        while (left <= right) {
+            middle = left + (right - left) / 2;
+            if (array[middle] > array[array.length - 1]) left = middle + 1;
+            else right = middle - 1;
         }
+        return left;
+    }
 
-        computeSums(candidates, target, result, currentSum, current, i + 1);
-        current.add(candidates[i]);
-        computeSums(candidates, target, result, currentSum + candidates[i], current, i);
-        computeSums(candidates, target, result, currentSum + candidates[i], current, i + 1);
-        current.removeLast();
+    private static int binarySearch(int[] array, int start, int end, int x) {
+        int left = start, right = end, middle;
+        while (left <= right) {
+            middle = left + (right - left) / 2;
+            if (array[middle] == x) return middle;
+            else if (array[middle] < x) left = middle + 1;
+            else right = middle - 1;
+        }
+        return -1;
     }
-}
+}

src/MedianOfTwoSortedArrays.java

@@ -0,0 +1,34 @@
+// https://leetcode.com/problems/median-of-two-sorted-arrays
+
+public class MedianOfTwoSortedArrays {
+    static public double findMedianSortedArrays(int[] nums1, int[] nums2) {
+        final int[] array = merge(nums1, nums2);
+        if (array.length % 2 == 1) {
+            return array[array.length / 2];
+        }
+        return ((double) array[array.length / 2 - 1] + array[array.length / 2]) / 2;
+    }
+
+    private static int[] merge(int[] array1, int[] array2) {
+        final int[] result = new int[array1.length + array2.length];
+        int i = 0, j = 0, k = 0;
+
+        while (i < array1.length && j < array2.length) {
+            if (array1[i] <= array2[j]) {
+                result[k++] = array1[i++];
+            } else {
+                result[k++] = array2[j++];
+            }
+        }
+
+        while (i < array1.length) {
+            result[k++] = array1[i++];
+        }
+
+        while (j < array2.length) {
+            result[k++] = array2[j++];
+        }
+
+        return result;
+    }
+}

src/SearchInRotatedSortedArray.java

@@ -1,28 +1,35 @@
 // https://leetcode.com/problems/search-in-rotated-sorted-array
 // T: O(logN)
-// SL O(1)
+// S: O(1)
 
 public class SearchInRotatedSortedArray {
-    int search(int[] array, int target) {
-        final int shift = minElementIndex(array);
-        int left = 0, right = array.length - 1, middle, realMiddle;
-        while (left <= right) {
-            middle = (left + right) / 2;
-            realMiddle = (middle + shift) % array.length;
-            if(array[realMiddle] == target) return realMiddle;
-            if(array[realMiddle] < target) left = middle + 1;
-            else right = middle - 1;
+    public int search(int[] nums, int target) {
+        final int pivotIndex = binarySearchPivotIndex(nums);
+        final int answer = binarySearch(nums, 0, pivotIndex - 1, target);
+        if (answer != -1) {
+            return answer;
         }
-        return -1;
+        return binarySearch(nums, pivotIndex, nums.length - 1, target);
     }
 
-    private int minElementIndex(int[] array) {
+    private static int binarySearchPivotIndex(int[] array) {
         int left = 0, right = array.length - 1, middle;
-        while(left < right){
-            middle = (left + right) / 2;
-            if(array[middle] > array[right]) left = middle + 1;
-            else right = middle;
+        while (left <= right) {
+            middle = left + (right - left) / 2;
+            if (array[middle] > array[array.length - 1]) left = middle + 1;
+            else right = middle - 1;
         }
         return left;
     }
+
+    private static int binarySearch(int[] array, int start, int end, int x) {
+        int left = start, right = end, middle;
+        while (left <= right) {
+            middle = left + (right - left) / 2;
+            if (array[middle] == x) return middle;
+            else if (array[middle] < x) left = middle + 1;
+            else right = middle - 1;
+        }
+        return -1;
+    }
 }