practice

Author: metanet

src/problems/leetcode/CombinationSumII.java

@@ -0,0 +1,79 @@
+package problems.leetcode;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+// https://leetcode.com/problems/combination-sum-ii/
+public class CombinationSumII {
+
+    public static void main(String[] args) {
+        for (List<Integer> l : combinationSum2(new int[] { 10, 1, 2, 2, 2, 2, 7, 6, 1, 1, 5 }, 8)) {
+            System.out.println(l);
+        }
+
+        // for (List<Integer> l : combinationSum2(new int[] { 10, 1, 2, 2, 7, 6, 1, 1, 5
+        // }, 8)) {
+        // System.out.println(l);
+        // }
+    }
+
+    // 1, 1, 1, 2, 2, 5, 6, 7, 10 target = 8
+
+    public static List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        // container to hold the final combinations
+        List<List<Integer>> results = new ArrayList<>();
+        Deque<Integer> comb = new ArrayDeque<>();
+        Map<Integer, Integer> counter = new HashMap<>();
+        for (int candidate : candidates) {
+            counter.compute(candidate, (k, v) -> v != null ? v + 1 : 1);
+        }
+
+        // convert the counter table to a list of (num, count) tuples
+        List<int[]> counterList = new ArrayList<>();
+        counter.forEach((key, value) -> {
+            counterList.add(new int[] { key, value });
+        });
+
+        backtrack(comb, target, 0, counterList, results);
+        return results;
+    }
+
+    private static void backtrack(Deque<Integer> comb,
+            int target, int i,
+            List<int[]> counter,
+            List<List<Integer>> results) {
+        if (target == 0) {
+            // make a deep copy of the current combination.
+            results.add(new ArrayList<Integer>(comb));
+            return;
+        } else if (target < 0) {
+            return;
+        }
+
+        for (int j = i; j < counter.size(); j++) {
+            int[] entry = counter.get(j);
+            int candidate = entry[0], freq = entry[1];
+            if (freq <= 0) {
+                continue;
+            }
+
+            // add a new element to the current combination
+            comb.addLast(candidate);
+            entry[1]--;
+
+            // continue the exploration with the updated combination
+            backtrack(comb, target - candidate, j, counter, results);
+
+            // backtrack the changes, so that we can try another candidate
+            entry[1]++;
+            comb.removeLast();
+        }
+    }
+}

src/problems/leetcode/InsertInterval.java

@@ -20,33 +20,38 @@ public static void main(String[] args) {
 
     }
 
-    public static int[][] insert(int[][] intervals, int[] newInterval) {
-        List<int[]> insertedIntervals = new ArrayList<>(intervals.length);
-        int i = 0;
-        while (i < intervals.length && intervals[i][0] <= newInterval[0]) {
-            insertedIntervals.add(intervals[i++]);
+    // runtime: O(N)
+    // space: O(N)
+    public static int[][] insert(int[][] intervals1, int[] newInterval) {
+        if (intervals1 == null || intervals1.length < 1) {
+            return new int[][] {newInterval};
         }
 
-        insertedIntervals.add(newInterval);
-
-        while (i < intervals.length) {
-            insertedIntervals.add(intervals[i++]);
-        }
-
-        LinkedList<int[]> mergedIntervals = new LinkedList<>();
-
-        for (int[] interval : insertedIntervals) {
-            if (mergedIntervals.isEmpty() || mergedIntervals.getLast()[1] < interval[0]) {
-                mergedIntervals.add(interval);
-                continue;
+        int[][] intervals2 = new int[][]{newInterval};
+        int i = 0, j = 0, n = intervals1.length, m = 1;
+        int[] interval = intervals1[i][0] > intervals2[j][0] ? intervals2[j++] : intervals1[i++];
+        List<int[]> result = new ArrayList<>();
+
+        while (i < n || j < m) {
+            int[] next;
+            if (i < n && j < m) {
+                next = intervals1[i][0] > intervals2[j][0] ? intervals2[j++] : intervals1[i++];   
+            } else if (i < n) {
+                next = intervals1[i++];
+            } else {
+                next = intervals2[j++];
+            }
+            if (next[0] <= interval[1]) {
+                interval[1] = Math.max(interval[1], next[1]);
+            } else {
+                result.add(interval);
+                interval = next;
             }
-
-            int[] prev = mergedIntervals.removeLast();
-            mergedIntervals.add(new int[]{prev[0], Math.max(prev[1], interval[1])});
         }
 
+        result.add(interval);
 
-        return mergedIntervals.toArray(new int[0][0]);
+        return result.toArray(new int[0][0]);
     }
 
     /*

src/problems/leetcode/LengthOfLastWord.java

@@ -0,0 +1,31 @@
+package problems.leetcode;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+// https://leetcode.com/problems/length-of-last-word/submissions/
+public class LengthOfLastWord {
+    
+    // runtime: O(N)
+    // space: O(N)
+    public int lengthOfLastWord(String s) {
+        if (s == null || s.length() < 1) {
+            return 0;
+        }
+
+        String[] words = s.trim().split(" ");
+        Collections.reverse(Arrays.asList(words));
+        for (String w : words) {
+            if (!w.isEmpty()) {
+                return w.length();
+            }
+        }
+
+        return 0;
+    }
+
+    public static void main(String[] args) {
+        
+    }
+
+}

src/problems/leetcode/MaximumSubarray.java

@@ -10,17 +10,17 @@ public static void main(String[] args) {
         System.out.println(maxSubArray(nums));
     }
 
+    // runtime: O(N)
+    // space: O(1)
     public static int maxSubArray(int[] nums) {
+        if (nums == null || nums.length < 1) {
+            return 0;
+        }
+        
         int maxSum = nums[0];
         for (int i = 1; i < nums.length; i++) {
-            int s = nums[i] + nums[i - 1];
-            if (nums[i] < s) {
-                nums[i] = s;
-            }
-
-            if (nums[i] > maxSum) {
-                maxSum = nums[i];
-            }
+            nums[i] = Math.max(nums[i], nums[i] + nums[i - 1]);
+            maxSum = Math.max(maxSum, nums[i]);
         }
 
         return maxSum;

src/problems/leetcode/MergeIntervals.java

@@ -10,11 +10,14 @@
  */
 public class MergeIntervals {
 
+    // runtime: O(NlgN)
+    // space: O(N)
     public static int[][] merge(int[][] intervals) {
         if (intervals == null || intervals.length == 0) {
             return new int[0][0];
         }
 
+        // sort by start time then end time
         Comparator<Object> c = Comparator.comparingInt(interval -> ((int[]) interval)[0])
                 .thenComparingInt(interval -> ((int[]) interval)[1]);
         Arrays.sort(intervals, c);

src/problems/leetcode/MinimumPathSum.java

@@ -1,5 +1,7 @@
 package problems.leetcode;
 
+import java.util.Arrays;
+
 /**
  * https://leetcode.com/problems/minimum-path-sum/
  */
@@ -11,27 +13,27 @@ public static void main(String[] args) {
     }
 
     public static int minPathSum(int[][] grid) {
-        if (grid == null || grid.length == 0 || grid[0].length == 0) {
+        if (grid == null || grid.length == 0) {
             return 0;
         }
-
         int m = grid.length, n = grid[0].length;
-        int[][] dp = new int[m + 1][n + 1];
-        for (int i = n - 1; i >= 0; i--) {
-            dp[m - 1][i] = grid[m - 1][i] + dp[m - 1][i + 1];
+        for (int i = 1; i < m; i++) {
+            grid[i][0] += grid[i - 1][0];
         }
-
-        for (int i = m - 1; i >= 0; i--) {
-            dp[i][n - 1] = grid[i][n - 1] + dp[i + 1][n - 1];
+        for (int j = 1; j < n; j++) {
+            grid[0][j] += grid[0][j - 1];
         }
-
-        for (int i = m - 2; i >= 0; i--) {
-            for (int j = n - 2; j >= 0; j--) {
-                dp[i][j] = grid[i][j] + Math.min(dp[i + 1][j], dp[i][j + 1]);
+        for (int i = 1; i < m; i++) {
+            for (int j = 1; j < n; j++) {
+                grid[i][j] += Math.min(grid[i - 1][j], grid[i][j - 1]);
             }
         }
 
-        return dp[0][0];
+        for (int[] row : grid) {
+            System.out.println(Arrays.toString(row));
+        }
+
+        return grid[m - 1][n - 1];
     }
 
     /*

src/problems/leetcode/PermutationSequence.java

@@ -0,0 +1,44 @@
+package problems.leetcode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+// https://leetcode.com/problems/permutation-sequence/solutions/
+
+public class PermutationSequence {
+
+    // https://leetcode.com/problems/permutation-sequence/solutions/22507/explain-like-i-m-five-java-solution-in-o-n/
+
+    // runtime: O(N^2)
+    public String getPermutation(int n, int k) {
+        List<Integer> numbers = new ArrayList<>();
+        int[] factorial = new int[n + 1];
+        StringBuilder sb = new StringBuilder();
+
+        // create an array of factorial lookup
+        int sum = 1;
+        factorial[0] = 1;
+        for (int i = 1; i <= n; i++) {
+            sum *= i;
+            factorial[i] = sum;
+        }
+        // factorial[] = {1, 1, 2, 6, 24, ... n!}
+
+        // create a list of numbers to get indices
+        for (int i = 1; i <= n; i++) {
+            numbers.add(i);
+        }
+        // numbers = {1, 2, 3, 4}
+
+        k--;
+        for (int i = 1; i <= n; i++) {
+            int index = k / factorial[n - i];
+            sb.append(String.valueOf(numbers.get(index)));
+            numbers.remove(index);
+            k -= index * factorial[n - i];
+        }
+
+        return String.valueOf(sb);
+    }
+
+}

src/problems/leetcode/RotateList.java

@@ -15,10 +15,7 @@ private static class ListNode {
 
         @Override
         public String toString() {
-            return "ListNode{" +
-                    "val=" + val +
-                    ", next=" + next +
-                    '}';
+            return String.valueOf(val) + (next != null ? " -> " + next : "");
         }
     }
 
@@ -61,14 +58,54 @@ public static void main(String[] args) {
         ListNode head = new ListNode(1);
         head.next = new ListNode(2);
         head.next.next = new ListNode(3);
-        head.next.next.next = new ListNode(4);
-        head.next.next.next.next = new ListNode(5);
+        // head.next.next.next = new ListNode(4);
+        // head.next.next.next.next = new ListNode(5);
 
-        int k = 5;
 
-        ListNode newHead = new RotateList().rotateRight(head, k);
+        int k = 4;
+
+        ListNode newHead = new RotateList().rotateRight2(head, k);
         System.out.println(newHead);
     }
 
+    public static ListNode rotateRight2(ListNode head, int k) {
+        if (head == null || head.next == null || k < 1) {
+            return head;
+        }
+
+        // 1 -> 2 -> 3    4 -> 5
+        // k=2
+        // n=1
+        // h
+        // t
+        // n=5                 t
+        // n=1
+        //           nt
+        //                nh
+
+        int n = 1;
+        ListNode tail = head;
+        while (tail.next != null) {
+            n++;
+            tail = tail.next;
+        }
+
+        k %= n;
+        if (k == 0) {
+            return head;
+        }
+        n -= k;
+        ListNode newTail = head;
+        while (--n > 0) {
+            newTail = newTail.next;
+        }
+
+        ListNode newHead = newTail.next;
+        newTail.next = null;
+        tail.next = head;
+
+        return newHead;
+    }
+
 
 }