Update dynamic programming problems and lodash utilities

Author: sudheerj

README.md

@@ -0,0 +1,29 @@
+package java1.algorithms.dynamicProgramming.coinsChange;
+import java.util.*;
+
+public class CoinsChange {
+    // TC: O(amount * numberOfCoins) SC: O(amount)
+    private static int coinsChange(int[] coins, int amount) {
+        int[] dp = new int[amount+1];
+        Arrays.fill(dp, amount+1);
+        dp[0] = 0;
+        
+        for(int i=1; i<=amount; i++) {
+            for(int coin: coins) {
+                if(i-coin >=0) {
+                    dp[i] = Math.min(dp[i], 1 + dp[i-coin]);
+                }
+            }
+        }
+        return dp[amount] == amount +1 ? -1 : dp[amount];
+    }
+
+    public static void main(String[] args) {
+        int[] coins1 = {1, 3, 4, 5};
+        int amount1 = 7;
+        int[] coins2 = {2, 4};
+        int amount2 = 3;
+        System.out.println(coinsChange(coins1, amount1));
+        System.out.println(coinsChange(coins2, amount2));
+    }
+}

src/java1/algorithms/dynamicProgramming/CoinsChange.java

@@ -0,0 +1,40 @@
+**Description:**
+ Given an array of coins(`coins`) that contains different coin denominations and an integer amount(`amount`) which represents the total amount of money you want to make with these coins. Calculate the minimum number of coins needed to make up the given amount. If it is not possible to made up the amount, return -1.
+
+**Note:** There is no limit on number of times each coin to be used.
+
+## Examples:
+Example 1:
+
+Input: coins = [1, 3, 4, 5], amount = 7
+Output: 2
+
+Example 2: 
+
+Input: coins = [2, 4], amount = 3
+Output: -1
+
+**Algorithmic Steps(Approach 1&2)**
+This problem is solved efficiently using **dynamic programming** approach by avoiding the recomputations of same subproblems. The algorithmic approach can be summarized as follows: 
+
+1. Initialize an array to hold the number of minimum coins for each amount value from `0` to given `amount`. By default, each value is assigned with out of bound value `amount+1`.
+   
+2. Since the amount `0` requires `0` coins, let's re-initialize the first value(`dp[0]=0`) with 0.
+   
+3. Iterate each amount value starting from `1` to `amount` to find the minimum coins required.
+
+4. Iterate over each coin to make up the amount value.
+
+5. If the difference between amount and coin value is greater than or equal to zero, the number of minimum coins is calculated by the minimum value of initial value(`dp[i]`) and remaining amount's coins incremented by 1(`1+dp[i-coin]`).
+   
+6. Repeat step 5 until all the icons verified.
+
+7. Repeat steps 4-5 until the number of minimum coins calculated for each amount value.
+
+8. Return `dp[amount]` which indicates the number of minimum coins required for give amount.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(amount * coins)`, where `amount` is the number of amount values from `1` to given input `amount` and `coins` indicates number of given coins. This is because we are traversing all the amount values with a list of coins. 
+
+Here, we will use array datastructure to store the minimum coins count for each amount value. Hence, the space complexity will be `O(amount)`.

src/java1/algorithms/dynamicProgramming/LongestCommonSubsequence.java

@@ -1,5 +1,5 @@
 // TC: O(nums * target) SC: O(target)
-package java1.algorithms.dynamicProgramming;
+package java1.algorithms.dynamicProgramming.combinationSum4;
 
 public class CombinationSum4 {
     private static int combinationSum4(int[] nums, int target) {
@@ -16,8 +16,9 @@ private static int combinationSum4(int[] nums, int target) {
     }
 
     public static void main(String[] args) {
-       int[] nums = {1, 2, 3};
-       int target = 4;
-       System.out.println(combinationSum4(nums, target));
+       int[] nums1 = {1, 2, 4}, nums2 = {7};
+       int target1 = 5, target2 = 6;
+       System.out.println(combinationSum4(nums1, target1));
+       System.out.println(combinationSum4(nums2, target2));
     }
 }

src/java1/algorithms/dynamicProgramming/LongestIncreasingSequence.java

@@ -0,0 +1,38 @@
+**Description:**
+Given an array of unique integers `nums` and a target integer `target`, find out the number of possible combinations that add up to given target.
+
+**Note:** Same element from `nums` can be used multiple times if required. Also, the different elements order considered as a different combination.
+
+## Examples:
+Example 1:
+
+Input: nums1 = [1, 2, 4], target1 = 5
+Output: 10
+
+Example 2: 
+
+Input: nums2 = [7], target2 = 6
+Output: 0
+
+**Algorithmic Steps(Approach 1&2)**
+This problem is solved efficiently using **bottom-up dynamic programming** approach by avoiding the recomputations of same subproblems. The algorithmic approach can be summarized as follows: 
+
+1. Create an array(`dp`) with the size of `length+1` and initialized all values to zero. This array is used to store the number of combinations that sum up to each value from `0` up to `target`.
+   
+2. The first value(`dp[0]=1`) is set to 1 since there will be only one possible combination(not using any elements) results in a sum of zero.
+   
+3. Iterate over all possible sub-targets(`i`) starting from `1` to `target` to find the combinations.
+      
+4. For each sub-target value `i`, iterate through all numbers of given array.
+
+5. If the number(`num`) is less than or equal to current sub-target(`i`), then update the possible combinations by adding the previous combinations.
+
+6. Repeat steps 4-5 until the target value is reached.
+
+7. Return the number of combinations from the last element of an array(i.e, `dp[target]`)
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(target * n)`, where `n` is the number of elements in `nums` and `target` is the number for which combinations needs to be calculated. This is because we need to traverse each sub-target and find the possible comnitions for each element of given array. 
+
+Here, we will use an array datastructure to store possible combinations for each sub-target. Hence, the space complexity will be `O(target)`.

src/java1/algorithms/dynamicProgramming/coinsChange/CoinsChange.java

@@ -1,13 +1,13 @@
-package java1.algorithms.dynamicProgramming;
+package java1.algorithms.dynamicProgramming.houseRobber;
 
 public class HouseRobber {
     // TC:O(n) SC:O(1)
     private static int robber1(int[] nums) {
-        int rob1 = nums[0], rob2 = Math.max(rob1, nums[1]);
-        for(int i=2; i< nums.length; i++) {
-            int temp = Math.max(nums[i]+rob1, rob2);
+        int rob1 = 0, rob2 = 0;
+        for(int num: nums) {
+            int newRob = Math.max(num+rob1, rob2);
             rob1 = rob2;
-            rob2 = temp;
+            rob2 = newRob;
         }
         return rob2;
     } 
@@ -16,16 +16,20 @@ private static int robber1(int[] nums) {
     private static int robber2(int[] nums) {
         int[] dp = new int[nums.length];
         dp[0] = nums[0];
-        dp[1] = nums[1];
+        dp[1] = Math.max(nums[0], nums[1]);
         for(int i=2; i<nums.length; i++) {
             dp[i] = Math.max(nums[i] + dp[i-2], dp[i-1]);
         }
         return dp[nums.length-1];
     }   
 
     public static void main(String[] args) {
-        int[] nums = {2,7,9,3,1};
-        System.out.println(robber1(nums));
-        System.out.println(robber2(nums));
+        int[] nums1 = {1, 5, 7, 2, 4};
+        int[] nums2 = {8, 1, 2, 9};
+        System.out.println(robber1(nums1));
+        System.out.println(robber2(nums1));
+
+        System.out.println(robber1(nums2));
+        System.out.println(robber2(nums2));
     }
 }

src/java1/algorithms/dynamicProgramming/coinsChange/CoinsChange.md

@@ -0,0 +1,36 @@
+**Description:**
+Given an integer array `nums` where `nums[i]` represents the amount of money in the `ith` house. Calculate the maximum amount of money you can rob from the houses. Remember that you cannot rob two adjacent houses because the security system will automatically alert the police if two adjacent houses were broken into on the same night.
+
+## Examples:
+Example 1:
+
+Input: nums1 = [1,5,7,2,4]
+Output: 12
+
+Example 2: 
+
+Input: nums2 = [8, 1, 2, 9]
+Output: 17
+
+**Algorithmic Steps(Approach 1&2)**
+This problem is solved efficiently using **Fibonacci pattern bottom-up dynamic programming** approach by avoiding the recomputations of same subproblems. The algorithmic approach can be summarized as follows: 
+
+1. Initialize first(`rob1`) and second(`rob2`) houses money with zero.
+   
+2. Iterate over all the houses and get the money at each `i`th house.
+
+3. Find the maximum possible money which can be robbed at each house. This is calculated by taking the maximum between sum of current house with second previous house and previous house money. This maximum money can be stored in a temporary varaible(`newRob`).
+   
+4. Move `rob1` pointing to next house(`rob2`). i.e, `rob1 = rob2`.
+      
+5. Update `rob2` pointing to current house(`newRob`) where the maximum possible money which can robbed at night is stored.
+
+6. Repeat steps 3-5 until all the houses visited.
+
+7. Return `rob2` which contains the maximum possible money which you can rob in the sequence of houses
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of houses with money stashed. This is because we need to traverse over each house to find the maximum money. 
+
+Here, we are not using any additonal datastructure other than two variables to store money. Hence, the space complexity will be `O(1)`.

src/java1/algorithms/dynamicProgramming/CombinationSum4.java renamed to src/java1/algorithms/dynamicProgramming/combinationSum4/CombinationSum4.java

@@ -1,28 +1,29 @@
 //TC: O(2n) ~O(n), SC:O(1)
-package java1.algorithms.dynamicProgramming;
+package java1.algorithms.dynamicProgramming.houseRobber2;
 
 public class HouseRobber2 {
     private static int rob(int[] nums) {
         if(nums.length == 0) return 0;
         if(nums.length == 1) return nums[0];
-        if(nums.length == 2) return Math.max(nums[0], nums[1]);
 
         return Math.max(robHelper(nums, 1, nums.length-1), robHelper(nums, 0, nums.length-2));
     }
 
     private static int robHelper(int[] nums, int start, int end) {
-        int rob1 = nums[start], rob2 = nums[start+1];
+        int rob1 = 0, rob2 = 0;
 
-        for(int i = 2; i< nums[end]; i++) {
-            int temp = Math.max(nums[i]+rob1, rob2);
+        for(int i = start; i<= end; i++) {
+            int newRob = Math.max(nums[i]+rob1, rob2);
             rob1 = rob2;
-            rob2 = temp;
+            rob2 = newRob;
         }
         return rob2;
     }
 
     public static void main(String[] args) {
-        int[] nums = {1, 2, 3, 1};
-        System.out.println(rob(nums));
+        int[] nums1 = {1, 5, 7, 2, 4}, nums2 = {1, 2, 3}, nums3 = {3};
+        System.out.println(rob(nums1));
+        System.out.println(rob(nums2));
+        System.out.println(rob(nums3));
     }
 }

src/java1/algorithms/dynamicProgramming/combinationSum4/CombinationSum4.md

@@ -0,0 +1,45 @@
+**Description:**
+Given an integer array `nums` where `nums[i]` represents the amount of money in the `i`th house. Calculate the maximum amount of money you can rob from the houses which are arranged in a circle. Remember that you cannot rob two adjacent houses(including the first and last house) because the security system will automatically alert the police if two adjacent houses were broken into on the same night.
+
+## Examples:
+Example 1:
+
+Input: nums1 = [1,5,7,2,4]
+Output: 11
+
+Example 2: 
+
+Input: nums2 = [1, 2, 3]
+Output: 3
+
+**Algorithmic Steps(Approach 1&2)**
+This problem is solved efficiently using **Fibonacci pattern bottom-up dynamic programming** approach by avoiding the recomputations of same subproblems. The algorithmic approach can be summarized as follows: 
+
+1. Accepts `nums` as input array which indicates the amount of money of each house.
+   
+2. Add base case conditions for zero and one houses. If there are no houses(`nums.length === 0`), the maximum money can get is zero. In case there is only one house(`nums.length === 1`), return that money as maximum amount.
+   
+3. Since the houses are arranged in a circle, the maximum money stolen from houses needs to be calculated for two sub-arrays(i.e, first subarray from first to last before house and second subarray from second to last house)
+   
+4. Create a helper function which accepts subarray as input to calculate the maximum amount can be robbed.
+
+5. Start the helper function by initializing first(`rob1`) and second(`rob2`) houses money with zero.
+   
+6. Iterate over all the houses and get the money at each `i`th house.
+
+7. Find the maximum possible money which can be robbed at each house. This is calculated by taking the maximum between sum of current house with second previous house and previous house money. This maximum money can be stored in a temporary varaible(`newRob`).
+   
+8. Move `rob1` pointing to next house(`rob2`). i.e, `rob1 = rob2`.
+      
+9. Update `rob2` pointing to current house(`newRob`) where the maximum possible money which can robbed at night is stored.
+
+10.  Repeat steps 3-5 until all the houses visited.
+
+11. Return `rob2` which contains the maximum possible money which you can rob in the sequence of houses
+
+12. Return the maximum money by invoking the helper function for subarrays mentioned in step3.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`(i.e, `O(2n) ~ O(n)`), where `n` is the number of houses with money stashed. This is because we need to traverse over two subarray sequence of houses to find the maximum money. 
+
+Here, we are not using any additonal datastructure other than two variables to store money. Hence, the space complexity will be `O(1)`.