More problems

Author: repl

build.gradle

@@ -19,6 +19,8 @@ repositories {
 dependencies {
     compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     compile group: 'edu.princeton.cs', name: 'algs4', version: '1.0.4'
+    implementation 'org.apache.commons:commons-lang3:3.11'
+    implementation 'com.google.guava:guava:29.0-jre'
     testCompile group: 'junit', name: 'junit', version: '4.12'
 }
 

pom.xml

@@ -28,6 +28,17 @@
             <artifactId>algs4</artifactId>
             <version>1.0.4</version>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.11</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>29.0-jre</version>
+            <type>bundle</type>
+        </dependency>
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
@@ -135,4 +146,4 @@
             </plugin>
         </plugins>
     </build>
-</project>
+</project>

src/main/java/array/AdvanceToEnd.java

@@ -14,6 +14,7 @@ public static boolean compute(List<Integer> input) {
         return compute(input, input.size() - 1);
     }
 
+    //Recursive - inefficient, can use dynamic programming
     public static boolean compute(List<Integer> input, int endIndex) {
         if (endIndex == 0) {
             return true;
@@ -27,4 +28,13 @@ public static boolean compute(List<Integer> input, int endIndex) {
         }
         return false;
     }
+
+    //Efficient
+    public static boolean computeItr(List<Integer> input) {
+        int furthestSoFar = 0, lastindex = input.size();
+        for (int i = 0; i < input.size() && i <= furthestSoFar; i++) {
+            furthestSoFar = Math.max(furthestSoFar, i + input.get(i));
+        }
+        return furthestSoFar >= lastindex;
+    }
 }

src/main/java/array/JumpOverNumbers.java

@@ -0,0 +1,26 @@
+package array;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class JumpOverNumbers {
+    public static void main(String[] args) {
+        List<Integer> input = Arrays.asList(3, 4, 1, 2, 5, 6, 9, 0, 1, 2, 3, 1);
+        System.out.println(compute(input));
+    }
+
+    public static int compute(List<Integer> input) {
+        int idx = 0, jumps = 0;
+        while (idx < input.size()) {
+            int val = input.get(idx);
+            if (val == 0) {
+                jumps = -1;
+                break;
+            } else {
+                idx += val;
+                jumps++;
+            }
+        }
+        return jumps;
+    }
+}

src/main/java/array/KLargestElements.java

@@ -1,5 +1,6 @@
 package array;
 
+import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 import java.util.PriorityQueue;
@@ -11,9 +12,11 @@ public static void main(String[] args) {
         int k = 3;
         int[] input = { 1, 23, 12, 9, 30, 2, 50};
         System.out.println(compute(input, k));
+        System.out.println(compute2(input, k));
     }
 
     private static List<Integer> compute(int[] nums, int k) {
+      //Max Queue. 
         PriorityQueue<Integer> pQueue = new PriorityQueue<>(new Comparator<Integer>() {
 
            @Override
@@ -31,4 +34,15 @@ public int compare(Integer o1, Integer o2) {
         }
         return IntStream.range(1, k+1).map(i -> pQueue.poll()).boxed().collect(Collectors.toList());
     }
+
+  private static List<Integer> compute2(int[] nums, int k) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>(k);
+    for (int i = 0; i< nums.length; i++) {
+      pq.add(nums[i]);
+      if (pq.size() > k) {
+        pq.poll();
+      }
+    }
+    return new ArrayList<Integer>(pq);
+  }
 }

src/main/java/array/MaximumSubarraySum.java

@@ -0,0 +1,40 @@
+package array;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class MaximumSubarraySum {
+    /*
+     * The maximum subarray problem is a task to find the series of contiguous
+     * elements with the maximum sum in any given array.
+     * 
+     * For instance, in the below array, the highlighted subarray has the maximum
+     * sum(6):
+     -3 1 -8 4 -1 2 1 -5 5
+             |      |
+     */
+    public static void main(String[] args) {
+        System.out.println("Max sum: " + compute(Arrays.asList(-3, 1, -8, 4, -1, 2, 1, -5, 5)));
+    }
+
+    //Kadane Algorithm
+    public static int compute(List<Integer> input) {
+        int maxSoFar = input.get(0);
+        int maxEndHere = maxSoFar;
+        int start = 0, end = 0;
+        for (int i = 1;i < input.size(); i++) {
+            if (input.get(i) > maxEndHere + input.get(i)) {
+                maxEndHere = input.get(i);
+                start = i;
+            } else {
+                maxEndHere = maxEndHere + input.get(i);
+            }
+            if (maxEndHere > maxSoFar) {
+                maxSoFar = maxEndHere;
+                end = i;
+            }
+        }
+        System.out.printf("Max sum sub array found with indices %d, %d\n", start, end);
+        return maxSoFar;
+    }
+}

src/main/java/array/NumberOfReversePairs.java

@@ -0,0 +1,42 @@
+package array;
+
+import java.util.Arrays;
+
+public class NumberOfReversePairs {
+  public static void main(String[] args) {
+    int[] input = {10, 3, 4, 2, 5, 7, 9, 11};
+    System.out.println("Result: " + divide(input, 0, input.length-1));
+  }
+
+  public static int divide(int[] input, int low, int high) {
+    if (low>=high) {
+      return 0;
+    }
+    int mid = low + (high - low)/2;
+    int leftInversions = divide(input, low, mid);
+    int rightInversions = divide(input, mid, high);
+    int mergeInversions = mergeAndCount(input, low, mid, high);
+    return leftInversions + rightInversions + mergeInversions;
+  }
+
+  public static int mergeAndCount(int[] input, int low, int mid, int high) {
+    int[] left = Arrays.copyOfRange(input, low, mid + 1);
+    int[] right = Arrays.copyOfRange(input, mid + 1, high + 1);
+    int i = 0, j = 0, k = low, inversions = 0;
+    while (i < left.length && j < right.length) {
+      if (left[i] <= right[j]) {
+        input[k++] = left[i++];
+      } else {
+        input[k++] = right[j++];
+        inversions += (mid + 1) - (low + i);
+      }
+    }
+    while (i<left.length) {
+      input[k++] = left[i++];
+    }
+    while (j<right.length) {
+      input[k++] = left[j++];
+    }
+    return inversions;
+  }
+}

src/main/java/dynamicprogramming/MoneyChange.java

@@ -66,18 +66,16 @@ private static int recursiveDP(int[] coins, int[] cache, int amt) {
     private static int iterativeDP(int[] coins, int[] cache, int amt) {
         cache[0] = 0;
         for (int coinAmt = 1; coinAmt <= amt; coinAmt++) {
-            if (cache[coinAmt] < 0) {
-                int minCoins = Integer.MAX_VALUE;
-                for (int coin: coins) {
-                    if (coinAmt - coin >= 0) {
-                        int currCoins = cache[coinAmt - coin] + 1;
-                        if (currCoins < minCoins) {
-                            minCoins = currCoins;
-                        }
+            int minCoins = Integer.MAX_VALUE;
+            for (int coin : coins) {
+                if (coinAmt - coin >= 0) {
+                    int currCoins = cache[coinAmt - coin] + 1;
+                    if (currCoins < minCoins) {
+                        minCoins = currCoins;
                     }
                 }
-                cache[coinAmt] = minCoins;
             }
+            cache[coinAmt] = minCoins;
         }
         return cache[amt];
     }

src/main/java/dynamicprogramming/SquareSubMatrix.java

@@ -21,7 +21,7 @@ public static void main(String[] args) {
 
         System.out.println("Recursive DP: " + recursiveDP(arr));
 
-        System.out.println("Iterative DP: " + iterativeDP());
+        System.out.println("Iterative DP: " + iterativeDP(arr));
     }
 
     private static int recursive(boolean arr[][]) {
@@ -68,7 +68,24 @@ private static int recursiveDPI(boolean[][] arr, int x, int y, int[][] cache) {
         return cache[x][y];
     }
 
-    private static int iterativeDP() {
-        return 0;
+    private static int iterativeDP(boolean arr[][]) {
+        int max = 0;
+        int[][] cache = new int[arr.length][arr[0].length];
+        for (int i=0;i<cache.length;i++) {
+            for (int j=0;j<cache[0].length;i++) {
+                // If we’re in the first row/column then
+                // the value is just 1 if that cell is
+                // true and 0 otherwise. In other rows and
+                // columns need to look up and to the left
+                if (i == 0 || j == 0) {
+                    cache[i][j] = arr[i][j] ? 1 : 0;
+                } else if (arr[i][j]) {
+                    cache[i][j] = Math.min(Math.min(cache[i][j - 1], cache[i - 1][j]), cache[i - 1][j - 1]) + 1;
+                }
+                if (cache[i][j] > max)
+                    max = cache[i][j];
+            }
+        }
+        return max;
     }
 }

src/main/java/dynamicprogramming/ZeroSumSubSequence.java

@@ -0,0 +1,46 @@
+package dynamicprogramming;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ZeroSumSubSequence {
+  public static void main(String[] args) {
+    System.out.println(compute(new int[] { 1, 2, -5, 1, 2, -1 }));
+  }
+
+  public static List<Integer> compute(int[] arr) {
+    return compute(arr, 0, 0);
+  }
+
+  public static List<Integer> compute(int[] arr, int index, int sum) {
+    List<Integer> ret = new ArrayList<>();
+    if (index == arr.length)
+      return ret;
+    if (sum - arr[index] == 0) {
+      ret.add(arr[index]);
+      return ret;
+    }
+    List<Integer> res1 = compute(arr, index + 1, sum - arr[index]);
+    if (res1.size() > 0) {
+      ret.add(arr[index]);
+      ret.addAll(res1);
+    }
+    List<Integer> res2 = compute(arr, index + 1, sum);
+    if (res2.size() > 0) {
+      return res2;
+    }
+    return ret;
+  }
+
+  /*public static List<Integer> iterative(int[] arr) {
+    int[][] sum = new int[arr.length][arr.length];
+    int s = 0, e = 0;
+    for (int i = 0; i < arr.length; i++) {
+      sum[i][i] = arr[i];
+    }
+    for (int i = 0; i < arr.length; i++) {
+      for (int j = i + 1; j < arr.length; j++) {
+      }
+    }
+    }*/
+}

src/main/java/dynamicprogramming/ZeroSumSubarray.java

@@ -38,7 +38,7 @@ public static Node deleteMiddleNode(Node n) {
                 temp = temp.next.next;
             } else {
                 if (temp.next != null) { //temp is at an odd numbered node and next/final node is even, so no mid node in this list.
-                    nodeBeforeMid = null;                    
+                    nodeBeforeMid = null;
                 }
                 temp = null;
             }