[LEET-0000] clean up

Author: fishercoder1534

leetcode-algorithms/README.md

@@ -0,0 +1,70 @@
+package com.stevesun.solutions;
+
+/**
+ * Given an Android 3x3 key lock screen and two integers m and n, where 1 ≤ m ≤ n ≤ 9, count the total number of unlock patterns of the Android lock screen, which consist of minimum of m keys and maximum n keys.
+
+ Rules for a valid pattern:
+ Each pattern must connect at least m keys and at most n keys.
+ All the keys must be distinct.
+ If the line connecting two consecutive keys in the pattern passes through any other keys, the other keys must have previously selected in the pattern. No jumps through non selected key is allowed.
+ The order of keys used matters.
+
+ Explanation:
+ | 1 | 2 | 3 |
+ | 4 | 5 | 6 |
+ | 7 | 8 | 9 |
+ Invalid move: 4 - 1 - 3 - 6
+ Line 1 - 3 passes through key 2 which had not been selected in the pattern.
+
+ Invalid move: 4 - 1 - 9 - 2
+ Line 1 - 9 passes through key 5 which had not been selected in the pattern.
+
+ Valid move: 2 - 4 - 1 - 3 - 6
+ Line 1 - 3 is valid because it passes through key 2, which had been selected in the pattern
+
+ Valid move: 6 - 5 - 4 - 1 - 9 - 2
+ Line 1 - 9 is valid because it passes through key 5, which had been selected in the pattern.
+
+ Example:
+ Given m = 1, n = 1, return 9.
+
+
+ */
+public class AndroidUnlockPatterns {
+
+    private int[][] jumps;
+    private boolean[] visited;
+
+    public int numberOfPatterns(int m, int n) {
+        jumps = new int[10][10];
+        jumps[1][3] = jumps[3][1] = 2;
+        jumps[4][6] = jumps[6][4] = 5;
+        jumps[7][9] = jumps[9][7] = 8;
+        jumps[1][7] = jumps[7][1] = 4;
+        jumps[2][8] = jumps[8][2] = jumps[1][9] = jumps[9][1]= 5;
+        jumps[9][3] = jumps[3][9] = 6;
+        jumps[3][7] = jumps[7][3] = 5;
+        visited = new boolean[10];
+        int count = 0;
+        count += dfs(1, 1, 0, m, n)*4;//1,3,7,9 are symmetric, so we only need to use 1 to do it once and then multiply the result by 4
+        count += dfs(2, 1, 0, m, n)*4;//2,4,6,8 are symmetric, so we only need to use 1 to do it once and then multiply the result by 4
+        count += dfs(5, 1, 0, m, n);
+        return count;
+    }
+
+    private int dfs(int num, int len, int count, int m, int n){
+        if(len >= m) count++;
+        len++;
+        if(len > n) return count;
+        visited[num] = true;
+        for(int next = 1; next <= 9; next++){
+            int jump = jumps[num][next];
+            if(!visited[next] && (jump == 0 || visited[jump])){
+                count = dfs(next, len, count, m, n);
+            }
+        }
+        visited[num] = false;//backtracking
+        return count;
+    }
+
+}

leetcode-algorithms/src/main/java/com/stevesun/solutions/AndroidUnlockPatterns.java

@@ -0,0 +1,84 @@
+package com.stevesun.solutions;
+
+/**
+ * Given a 2D grid, each cell is either a wall 'W', an enemy 'E' or empty '0' (the number zero), return the maximum enemies you can kill using one bomb.
+ The bomb kills all the enemies in the same row and column from the planted point until it hits the wall since the wall is too strong to be destroyed.
+ Note that you can only put the bomb at an empty cell.
+
+ Example:
+ For the given grid
+
+ 0 E 0 0
+ E 0 W E
+ 0 E 0 0
+
+ return 3. (Placing a bomb at (1,1) kills 3 enemies)
+ */
+public class BombEnemies {
+
+    public int maxKilledEnemies(char[][] grid) {
+        int m = grid.length;
+        if(grid == null || m == 0) return 0;
+        int n = grid[0].length;
+
+        int[][] max = new int[m][n];
+
+        for(int i = 0; i < m; i++){
+            for(int j = 0; j < n; j++){
+
+                if(grid[i][j] == '0'){
+                    int count = 0;
+
+                    //count all possible hits in its upward direction
+                    for(int k = j-1; k >= 0; k--){
+                        if(grid[i][k] == 'E') {
+                            count++;
+                        } else if(grid[i][k] == 'W') {
+                            break;
+                        }
+                    }
+
+                    //count all possible hits in its downward direction
+                    for(int k = j+1; k < n; k++){
+                        if(grid[i][k] == 'E') {
+                            count++;
+                        } else if(grid[i][k] == 'W') {
+                            break;
+                        }
+                    }
+
+                    //count all possible hits in its right direction
+                    for(int k = i+1; k < m; k++){
+                        if(grid[k][j] == 'E') {
+                            count++;
+                        } else if(grid[k][j] == 'W') {
+                            break;
+                        }
+                    }
+
+                    //count all possible hits in its left direction
+                    for(int k = i-1; k >= 0; k--){
+                        if(grid[k][j] == 'E') {
+                            count++;
+                        } else if(grid[k][j] == 'W') {
+                            break;
+                        }
+                    }
+
+                    max[i][j] = count;
+
+                }
+            }
+        }
+
+        int result = 0;
+
+        for(int i = 0; i < m; i++){
+            for(int j = 0; j < n; j++){
+                if(max[i][j] > result) result = max[i][j];
+            }
+        }
+        return result;
+    }
+
+}

leetcode-algorithms/src/main/java/com/stevesun/solutions/BombEnemies.java

@@ -0,0 +1,43 @@
+package com.stevesun.solutions;
+
+/**
+ * Given n balloons, indexed from 0 to n-1. Each balloon is painted with a number on it represented by array nums. You are asked to burst all the balloons. If the you burst balloon i you will get nums[left] * nums[i] * nums[right] coins. Here left and right are adjacent indices of i. After the burst, the left and right then becomes adjacent.
+
+ Find the maximum coins you can collect by bursting the balloons wisely.
+
+ Note:
+ (1) You may imagine nums[-1] = nums[n] = 1. They are not real therefore you can not burst them.
+ (2) 0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100
+
+ Example:
+
+ Given [3, 1, 5, 8]
+
+ Return 167
+
+ nums = [3,1,5,8] --> [3,5,8] -->   [3,8]   -->  [8]  --> []
+ coins =  3*1*5      +  3*5*8    +  1*3*8      + 1*8*1   = 167
+ */
+public class BurstBalloons {
+
+    public int maxCoins(int[] iNums) {
+        int[] nums = new int[iNums.length + 2];
+        int n = 1;
+        for (int x : iNums)
+            if (x > 0)
+                nums[n++] = x;
+        nums[0] = nums[n++] = 1;
+
+        int[][] dp = new int[n][n];
+        for (int k = 2; k < n; ++k)
+            for (int left = 0; left < n - k; ++left) {
+                int right = left + k;
+                for (int i = left + 1; i < right; ++i)
+                    dp[left][right] = Math.max(dp[left][right],
+                            nums[left] * nums[i] * nums[right] + dp[left][i] + dp[i][right]);
+            }
+
+        return dp[0][n - 1];
+    }
+
+}

leetcode-algorithms/src/main/java/com/stevesun/solutions/BurstBalloons.java

@@ -0,0 +1,44 @@
+package com.stevesun.solutions;
+
+/**
+ * You are given coins of different denominations and a total amount of money amount. Write a function to compute the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.
+
+ Example 1:
+ coins = [1, 2, 5], amount = 11
+ return 3 (11 = 5 + 5 + 1)
+
+ Example 2:
+ coins = [2], amount = 3
+ return -1.
+
+ Note:
+ You may assume that you have an infinite number of each kind of coin.
+ */
+public class CoinChange {
+
+    public int coinChange(int[] coins, int amount) {
+        if(amount < 1) return 0;
+        int[] count = new int[amount];
+        int result = helper(coins, amount, count);
+
+        return result;
+    }
+
+    //remaining means the remaining coins after the last step;
+    //count[remaining] means the minimum number of coins to sum up to remaining
+    private int helper(int[] coins, int remaining, int[] count) {
+        if(remaining < 0) return -1;//not valid case, thus, per problem description, we should return -1
+        if(remaining == 0) return 0;//completed, this is also a base case for this recursive function
+        if(count[remaining-1] != 0) return count[remaining-1];//already computed, so reuse it.
+        int min = Integer.MAX_VALUE;
+        for(int coin : coins){
+            int res = helper(coins, remaining-coin, count);
+            if(res >= 0 && res < min){
+                min = 1+res;
+            }
+        }
+        return count[remaining-1] = (min == Integer.MAX_VALUE) ? -1 : min;
+
+    }
+
+}

leetcode-algorithms/src/main/java/com/stevesun/solutions/CoinChange.java

@@ -6,6 +6,19 @@
 import java.util.Arrays;
 import java.util.List;
 
+/**Given a set of candidate numbers (C) (without duplicates) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.
+
+ The same repeated number may be chosen from C unlimited number of times.
+
+ Note:
+ All numbers (including target) will be positive integers.
+ The solution set must not contain duplicate combinations.
+ For example, given candidate set [2, 3, 6, 7] and target 7,
+ A solution set is:
+ [
+ [7],
+ [2, 2, 3]
+ ]*/
 public class CombinationSum {
 
     public List<List<Integer>> combinationSum(int[] candidates, int target) {

leetcode-algorithms/src/main/java/com/stevesun/solutions/CombinationSum.java

@@ -5,7 +5,29 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+/**Given an integer array with all positive numbers and no duplicates, find the number of possible combinations that add up to a positive integer target.
 
+ Example:
+
+ nums = [1, 2, 3]
+ target = 4
+
+ The possible combination ways are:
+ (1, 1, 1, 1)
+ (1, 1, 2)
+ (1, 2, 1)
+ (1, 3)
+ (2, 1, 1)
+ (2, 2)
+ (3, 1)
+
+ Note that different sequences are counted as different combinations.
+
+ Therefore the output is 7.
+ Follow up:
+ What if negative numbers are allowed in the given array?
+ How does it change the problem?
+ What limitation we need to add to the question to allow negative numbers?*/
 public class CombinationSumIV {
     //since this question doesn't require to return all the combination result, instead, it just wants one number, we could use DP
     //the idea is similar to Climbing Stairs.

leetcode-algorithms/src/main/java/com/stevesun/solutions/CombinationSumIV.java

@@ -0,0 +1,43 @@
+package com.stevesun.solutions;
+
+/**
+ * Given an integer array nums, return the number of range sums that lie in [lower, upper] inclusive.
+ Range sum S(i, j) is defined as the sum of the elements in nums between indices i and j (i ≤ j), inclusive.
+
+ Note:
+ A naive algorithm of O(n2) is trivial. You MUST do better than that.
+
+ Example:
+ Given nums = [-2, 5, -1], lower = -2, upper = 2,
+ Return 3.
+ The three ranges are : [0, 0], [2, 2], [0, 2] and their respective sums are: -2, -1, 2.
+ */
+public class CountOfRangeSum {
+
+    public int countRangeSum(int[] nums, int lower, int upper) {
+        int n = nums.length;
+        long[] sums = new long[n+1];
+        for(int i = 0; i < n; i++){
+            sums[i+1] = sums[i] + nums[i];
+        }
+        return countWhileMergeSort(sums, 0, n+1, lower, upper);
+    }
+
+    private int countWhileMergeSort(long[] sums, int start, int end, int lower, int upper) {
+        if(end - start <= 1) return 0;
+        int mid = (start+end)/2;
+        int count = countWhileMergeSort(sums, start, mid, lower, upper) + countWhileMergeSort(sums, mid, end, lower, upper);
+        int j = mid, k = mid, t = mid;
+        long[] cache = new long[end-start];
+        for(int i = start, r = 0; i < mid; i++, r++){
+            while(k < end && sums[k] - sums[i] < lower) k++;
+            while(j < end && sums[j] - sums[i] <= upper) j++;
+            while(t < end && sums[t] < sums[i]) cache[r++] = sums[t++];
+            cache[r] = sums[i];
+            count += j-k;
+        }
+        System.arraycopy(cache, 0, sums, start, t-start);
+        return count;
+    }
+
+}

leetcode-algorithms/src/main/java/com/stevesun/solutions/CountOfRangeSum.java

@@ -0,0 +1,60 @@
+package com.stevesun.solutions;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * You are given an integer array nums and you have to return a new counts array. The counts array has the property where counts[i] is the number of smaller elements to the right of nums[i].
+
+ Example:
+
+ Given nums = [5, 2, 6, 1]
+
+ To the right of 5 there are 2 smaller elements (2 and 1).
+ To the right of 2 there is only 1 smaller element (1).
+ To the right of 6 there is 1 smaller element (1).
+ To the right of 1 there is 0 smaller element.
+ Return the array [2, 1, 1, 0].
+
+ */
+public class CountOfSmallerNumbersAfterSelf {
+
+    class Node{
+        int val;
+        int sum;
+        int dup = 1;
+        Node left;
+        Node right;
+        public Node(int v, int s){
+            this.val = v;
+            this.sum = s;
+        }
+    }
+
+    public List<Integer> countSmaller(int[] nums) {
+        Integer[] ans = new Integer[nums.length];
+        Node root = null;
+        for(int i = nums.length-1; i >= 0; i--){
+            root = insertNode(nums[i], root, i, 0, ans);
+        }
+        return Arrays.asList(ans);
+    }
+
+    Node insertNode(int val, Node node, int i, int prevSum, Integer[] ans){
+        if(node == null){
+            node = new Node(val, 0);
+            ans[i] = prevSum;
+        } else if(val == node.val){
+            node.dup += 1;
+            ans[i] = prevSum + node.sum;
+        } else if(val > node.val){
+            node.right = insertNode(val, node.right, i, prevSum + node.sum + node.dup, ans);
+        } else {
+            node.sum += 1;
+            node.left = insertNode(val, node.left, i, prevSum, ans);
+        }
+
+        return node;
+    }
+
+}