Java 9

Introduction to dynamic programming

what is the result of

1+1+1+1+1+1+1+1

Answer is Eight

If we add another +1 to the expression above the output is Nine

We are able to calculate faster for additional +1 because we memorized the previous result

So In dynamic programming we remember stuff to save time later

If you have sloved a problem with given input than save the result for future reference to avoid solving the same problem again and again

Essence of Dynamic Programming

Components of Dynamic Programming

Recursion
Memoization

Characteristics of Dynamic Programming

Optimal Substructure property
- A given problem has optimal substructure property, If an Optimal solution of the given problem can be obtained by using the optimal solution of its subproblems.
- fib(n) = fib(n-1) + fib(n-2) if n>1
Overlapping Subproblems
- Subproblems are a subset of the original problem. Any problem has overlapping subproblems, if finding its solution requires solving the same problem again and again.

Overlapping sub problems

Dynamic Programming Methods

Top-down (Memoization)
- It is similar approach to recursion as it looks for value in the table first which acts as a cache before computing solutions.
- If the solution is found than the result will be taken otherwise the problem will be solved and result is stored for the future use.
Bottom-up (Tabulation)
- Tabulation is the opposite of top-down approach and avoids recursion
- In this approach we solve the problem in bottom up manner by solving all the related sub problems first.

Technique to Solve DP problems

To solve a dynamic problem we ca use the fast method
- Find a recursive solution
- Analyse the solution (Look for overlapping problems)
- Save the result for future (Use array for caching purpose)
- Tweek the solution to make it more powerful by eliminating recursion overhead. (Known as bottom up approach)

Fibonacci number

Write an efficient program to find nth Fibonacci number ?

a fibonacci series looks like 0,1,1,2,3,5,8,13,21....

Recursive Solution

 public static int fib(int n) {
        if (n < 2)
            return n;
        return fib(n - 1) + fib(n - 2);
    }

Memoization in recursive solution

 public static int fib(int n, int[] cache) {
        if (n < 2) {
            return n;
        }
        if (cache[n] != 0) {
            return cache[n];
        }
        return cache[n] = fib(n - 1, cache) + fib(n - 2, cache);
    }

Efficient Bottom up approach

 public static int fibTabulation(int n) {
        int[] cache = new int[n + 1];
        cache[0] = 0;
        cache[1] = 1;
        for (int i = 2; i < cache.length; i++) {
            cache[i] = cache[i - 1] + cache[i - 2];
        }
        return cache[n];
    }

Eliminating caching

 public static int fibEffec(int n) {
        if(n<2){
            return n;
        }
        int first = 0;
        int second = 1;
        int sum = 0;
        for (int i = 2; i < n + 1; i++) {
            sum = first + second;
            first = second;
            second = sum;
        }
        return sum;
    }

Complete Program

 package com.algo.DP;
 
public class Demo1 {
 
    public static void main(String[] args) {
        int n = 4;
        int[] cache = new int[n + 1];
        System.out.println(fib(n));
        System.out.println(fib(n, cache));
        System.out.println(fibTabulation(n));
        System.out.println(fibEffec(n));
    }
 
    public static int fibEffec(int n) {
        if(n<2){
            return n;
        }
        int first = 0;
        int second = 1;
        int sum = 0;
        for (int i = 2; i < n + 1; i++) {
            sum = first + second;
            first = second;
            second = sum;
        }
        return sum;
    }
 
    public static int fibTabulation(int n) {
        int[] cache = new int[n + 1];
        cache[0] = 0;
        cache[1] = 1;
        for (int i = 2; i < cache.length; i++) {
            cache[i] = cache[i - 1] + cache[i - 2];
        }
        return cache[n];
    }
 
    public static int fib(int n) {
        if (n < 2)
            return n;
        return fib(n - 1) + fib(n - 2);
    }
 
    public static int fib(int n, int[] cache) {
        if (n < 2) {
            return n;
        }
        if (cache[n] != 0) {
            return cache[n];
        }
        return cache[n] = fib(n - 1, cache) + fib(n - 2, cache);
    }
}

Staircase problem

A child is climbing up a the staircase with n steps and hop either 1 step or 2 step at a time.

Implement a method to count how many possible ways the child can climb up the stairs.

Recursive Solution

 static int stairCaseSolution(int n) {
        if (n < 0) {
            return 0;
        }
        if (n == 0) {
            return 1;
        }
        return stairCaseSolution(n - 1) + stairCaseSolution(n - 2);
    }

Recursive Solution with caching (Memoization)

 static int stairCaseSolution(int n, int[] arr) {
        if (n < 0) {
            return 0;
        }
        if (n == 0) {
            return 1;
        }
        if (arr[n] != 0) {
            return arr[n];
        }
        return arr[n] = stairCaseSolution(n - 1, arr) + stairCaseSolution(n - 2, arr);
    }

Bottom Up approach (Tabulation )

 static int stairCaseBottomUpSolution(int n, int[] arr) {
        arr[0] = 1;
        arr[1] = 1;
        for (int i = 2; i <= n; i++) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        return arr[n];
    }

Tabulation without caching

 static int stairCaseBottomUpSolutionWithoutCache(int n) {
        int first = 1, second = 1, sum = 0;
 
        for (int i = 2; i <= n; i++) {
            sum = first + second;
            first = second;
            second = sum;
 
        }
        return sum;
    }

House Robber problem

You are a professional robber planning to rob the house along a street.
Each house has a certain amount of money stashed.
The only constraint stopping you for robbing each of them is that adjacent houses have security systems connected and it will be automatically contact the police if two adjacent houses were broken into the same night.
Given a list of non negative integers represent the amount of money you can rob tonight without alerting the police

Sample 1
- input : {2,7,9,3,1}
- rob house 1,3 and 5
- output : 12

Sample 2
- input : {5,3,4,11,2}
- rob house : 1 and 4
- output : 16

Case 1 [ Rob the current house ]:
- if the current ith house is selected for robbery it means (i-1)th and (i+1)th house can't be robbed but can safely proceed to (i-2)th and (i+2)th.
- ith_house _is_selected = current_house_value + rob(i-2)
Case 2 [ Do not rob the current house]:
- if ith house is not robbed it means robber will get all the possible money of (i-1)th and (i+1)th house and so on.
- ith_house_is_not_selected = rob(i-1)

Recursive Approach

 static int robCache(int[] arr, int n, int[] cache) {
        if (n < 0) {
            return 0;
        }
        if (cache[n] != 0) {
            return cache[n];
        }
        int ith_house_selected = robCache(arr, n - 2, cache) + arr[n];
        int ith_house_not_selected = robCache(arr, n - 1, cache);
        return cache[n] = Math.max(ith_house_selected, ith_house_not_selected);
    }

 static int houseRobberBottomUpSolution(int[] arr, int[] cache) {
        cache[0] = arr[0];
        cache[1] = Math.max(arr[0], arr[1]);
        for (int i = 2; i < arr.length; i++) {
            cache[i]=Math.max(cache[i-1],cache[i-2]+arr[i]);
        }
        return cache[arr.length-1];
    }

Memoization

Tabulation

 static int houseRobberBottomUpSolution(int[] arr, int[] cache) {
        cache[0] = arr[0];
        cache[1] = Math.max(arr[0], arr[1]);
        for (int i = 2; i < arr.length; i++) {
            cache[i]=Math.max(cache[i-1],cache[i-2]+arr[i]);
        }
        return cache[arr.length-1];
    }

Tabulation without Caching

   static int houseRobberBottomUpSolutionWithoutCache(int[] arr) {
        int prev2 = arr[0];
        int prev1 = Math.max(arr[0], arr[1]);
        for (int i = 2; i < arr.length; i++) {
            int tmp = prev1;
            prev1 = Math.max(prev2 + arr[i], prev1);
            prev2 = tmp;
        }
        return prev1;
    }

 package com.algo.DP;
 
public class HouseRobberProblem {
 
    public static void main(String[] args) {
 
        int[] arr = {2, 45, 8, 7, 98, 24};
        int[] cache = new int[arr.length + 1];
        System.out.println(rob(arr, arr.length - 1));
        System.out.println(robCache(arr, arr.length - 1, cache));
        System.out.println(houseRobberBottomUpSolution(arr,cache));
        System.out.println(houseRobberBottomUpSolutionWithoutCache(arr));
 
    }
 
    static int rob(int[] arr, int n) {
 
        if (n < 0) {
            return 0;
        }
        int ith_house_selected = rob(arr, n - 2) + arr[n];
        int ith_house_not_selected = rob(arr, n - 1);
        return Math.max(ith_house_selected, ith_house_not_selected);
    }
 
    static int robCache(int[] arr, int n, int[] cache) {
        if (n < 0) {
            return 0;
        }
        if (cache[n] != 0) {
            return cache[n];
        }
        int ith_house_selected = robCache(arr, n - 2, cache) + arr[n];
        int ith_house_not_selected = robCache(arr, n - 1, cache);
        return cache[n] = Math.max(ith_house_selected, ith_house_not_selected);
    }
 
    static int houseRobberBottomUpSolution(int[] arr, int[] cache) {
        cache[0] = arr[0];
        cache[1] = Math.max(arr[0], arr[1]);
        for (int i = 2; i < arr.length; i++) {
            cache[i]=Math.max(cache[i-1],cache[i-2]+arr[i]);
        }
        return cache[arr.length-1];
    }
 
    static int houseRobberBottomUpSolutionWithoutCache(int[] arr) {
        int prev2 = arr[0];
        int prev1 = Math.max(arr[0], arr[1]);
        for (int i = 2; i < arr.length; i++) {
            int tmp = prev1;
            prev1 = Math.max(prev2 + arr[i], prev1);
            prev2 = tmp;
        }
        return prev1;
    }
}

Complete Program

Longest Common substring

Given two strings S1 and S2, find the length of the longest common substring which is common in both the strings.
Input :
- S1 : JavaProgrammingLanguage
- S2 : JavaLanguage
Output : 8

 static int longestCommonSubString(char[] str1, char[] str2, int m, int n, int lcsCount) {
        if (m <= 0 || n <= 0) {
            return lcsCount;
        }
        int lcsCount1 = lcsCount;
        if (str1[m - 1] == str2[n - 1]) {
            lcsCount1 = longestCommonSubString(str1, str2, m - 1, n - 1, lcsCount + 1);
        }
        int lcsCount2 = longestCommonSubString(str1, str2, m, n - 1, 0);
        int lcsCount3 = longestCommonSubString(str1, str2, m - 1, n, 0);
        return Math.max(lcsCount1, Math.max(lcsCount2, lcsCount3));
    }

Recursive Solution

Recursive Solution with Caching

 static int longestCommonSubStringWithCaching(char[] str1, char[] str2, int m, int n, int lcsCount, int cache[][][]) {
        if (m <= 0 || n <= 0) {
            return lcsCount;
        }
        if (cache[m][n][lcsCount] != 0) {
            return cache[m][n][lcsCount];
        }
        int lcsCount1 = lcsCount;
        if (str1[m - 1] == str2[n - 1]) {
            lcsCount1 = longestCommonSubStringWithCaching(str1, str2, m - 1, n - 1, lcsCount + 1, cache);
        }
        int lcsCount2 = longestCommonSubStringWithCaching(str1, str2, m, n - 1, 0, cache);
        int lcsCount3 = longestCommonSubStringWithCaching(str1, str2, m - 1, n, 0, cache);
        return cache[m][n][lcsCount] = Math.max(lcsCount1, Math.max(lcsCount2, lcsCount3));
 
    }

  static int longestCommonSubStringBottomUpSolution(char[] str1, char[] str2, int m, int n) {
        int result = 0;
        int[][] memo = new int[m + 1][n + 1];
 
        for (int i = 0; i <= m; i++) {
            for (int j = 0; j <= n; j++) {
                if (i == 0 || j == 0) {
                    memo[i][j] = 0;
                } else if (str1[i - 1] == str2[j - 1]) {
                    memo[i][j] = memo[i - 1][j - 1] + 1;
                    result = Math.max(memo[i][j], result);
                } else {
                    memo[i][j] = 0;
                }
            }
        }
        return result;
    }

Bottom Up approach

Complete Program

 package com.algo.DP;
 
public class LongestCommonSubStringProblem {
 
    public static void main(String[] args) {
        String str = "JavaProgrammingLanguage";
        String str2 = "JavaLanguage";
//        String str = "JavaProgram";
//        String str2 = "JavaProgram";
        int m = str.length();
        int n = str2.length();
        int[][][] cache = new int[m + 1][n + 1][Math.max(m, n) + 1];
        System.out.println(longestCommonSubString(str.toCharArray(), str2.toCharArray(), str.length(), str2.length(), 0));
        System.out.println(longestCommonSubStringWithCaching(str.toCharArray(), str2.toCharArray(), str.length(), str2.length(), 0, cache));
        System.out.println(longestCommonSubStringBottomUpSolution(str.toCharArray(), str2.toCharArray(), str.length(), str2.length()));
    }
 
 
    static int longestCommonSubStringBottomUpSolution(char[] str1, char[] str2, int m, int n) {
        int result = 0;
        int[][] memo = new int[m + 1][n + 1];
        for (int i = 0; i <= m; i++) {
            for (int j = 0; j <= n; j++) {
                if (i == 0 || j == 0) {
                    memo[i][j] = 0;
                } else if (str1[i - 1] == str2[j - 1]) {
                    memo[i][j] = memo[i - 1][j - 1] + 1;
                    result = Math.max(memo[i][j], result);
                } else {
                    memo[i][j] = 0;
                }
            }
        }
        return result;
    }
 
    static int longestCommonSubStringWithCaching(char[] str1, char[] str2, int m, int n, int lcsCount, int cache[][][]) {
        if (m <= 0 || n <= 0) {
            return lcsCount;
        }
        if (cache[m][n][lcsCount] != 0) {
            return cache[m][n][lcsCount];
        }
        int lcsCount1 = lcsCount;
        if (str1[m - 1] == str2[n - 1]) {
            lcsCount1 = longestCommonSubStringWithCaching(str1, str2, m - 1, n - 1, lcsCount + 1, cache);
        }
        int lcsCount2 = longestCommonSubStringWithCaching(str1, str2, m, n - 1, 0, cache);
        int lcsCount3 = longestCommonSubStringWithCaching(str1, str2, m - 1, n, 0, cache);
        return cache[m][n][lcsCount] = Math.max(lcsCount1, Math.max(lcsCount2, lcsCount3));
 
    }
 
    static int longestCommonSubString(char[] str1, char[] str2, int m, int n, int lcsCount) {
        if (m <= 0 || n <= 0) {
            return lcsCount;
        }
        int lcsCount1 = lcsCount;
        if (str1[m - 1] == str2[n - 1]) {
            lcsCount1 = longestCommonSubString(str1, str2, m - 1, n - 1, lcsCount + 1);
        }
        int lcsCount2 = longestCommonSubString(str1, str2, m, n - 1, 0);
        int lcsCount3 = longestCommonSubString(str1, str2, m - 1, n, 0);
        return Math.max(lcsCount1, Math.max(lcsCount2, lcsCount3));
    }
}

Longest Common Subsequence

Given two strings S1 and S2, find the length of the longest common subsequence which is common in both the strings
Input :
- S1 : ACEDBFD
- S1 : AECDF
Output : 4
Explanation : The longest common subsequence is ACDF therefore the length is 4.

Algorithm :

Case 1 : If character X[i] matches with Y[i], We can recursively match for remaining characters
Case 2 : If character of both the strings are different, we start two new recursive calls by skipping one character separately from each String.

Recursive Solution

 static int longestCommonSubSequenceRecursiveSolution(char[] str1, char[] str2, int m, int n) {
        if (m <= 0 || n <= 0) {
            return 0;
        }
        if (str1[m - 1] == str2[n - 1]) {
            return 1 + longestCommonSubSequenceRecursiveSolution(str1, str2, m - 1, n - 1);
        }
        return Math.max(
                longestCommonSubSequenceRecursiveSolution(str1, str2, m, n - 1),
                longestCommonSubSequenceRecursiveSolution(str1, str2, m - 1, n));
 
    }

Recursive Solution with Caching (Memoization)

 static int longestCommonSubSequenceRecursiveSolutionWithCache(char[] str1, char[] str2, int m, int n, int[][] cache) {
        if (m <= 0 || n <= 0) {
            return 0;
        }
        if (cache[m][n] != 0) {
            return cache[m][n];
        }
 
        if (str1[m - 1] == str2[n - 1]) {
            return 1 + longestCommonSubSequenceRecursiveSolutionWithCache(str1, str2, m - 1, n - 1, cache);
        }
 
        return cache[m][n] = Math.max(
                longestCommonSubSequenceRecursiveSolutionWithCache(str1, str2, m, n - 1, cache),
                longestCommonSubSequenceRecursiveSolutionWithCache(str1, str2, m - 1, n, cache)
        );
 
    }

  static int longestCommonSubSequenceBottomUpSolution(char[] str1, char[] str2, int m, int n) {
        int[][] memo = new int[m + 1][n + 1];
        for (int i = 0; i <= m; i++) {
            for (int j = 0; j <= n; j++) {
                if (i == 0 || j == 0) {
                    memo[i][j] = 0;
                } else if (str1[i - 1] == str2[j - 1]) {
                    memo[i][j] = memo[i - 1][j - 1] + 1;
                } else {
                    memo[i][j] = Math.max(memo[i - 1][j], memo[i][j - 1]);
                }
            }
        }
        return memo[m][n];
    }

Tabulation Solution

 package com.algo.DP;
 
public class LongestCommonSubSequenceProblem {
 
    public static void main(String[] args) {
        String str = "Javaaid";
        String str2 = "Javaid";
        int m = str.length();
        int n = str2.length();
        int[][] cache = new int[m + 1][n + 1];
//        System.out.println(longestCommonSubSequenceRecursiveSolution(str.toCharArray(), str2.toCharArray(), m, n));
//        System.out.println(longestCommonSubSequenceRecursiveSolutionWithCache(str.toCharArray(), str2.toCharArray(), m, n, cache));
        System.out.println(longestCommonSubSequenceBottomUpSolution(str.toCharArray(), str2.toCharArray(), m, n));
    }
 
    static int longestCommonSubSequenceBottomUpSolution(char[] str1, char[] str2, int m, int n) {
        int[][] memo = new int[m + 1][n + 1];
        for (int i = 0; i <= m; i++) {
            for (int j = 0; j <= n; j++) {
                if (i == 0 || j == 0) {
                    memo[i][j] = 0;
                } else if (str1[i - 1] == str2[j - 1]) {
                    memo[i][j] = memo[i - 1][j - 1] + 1;
                } else {
                    memo[i][j] = Math.max(memo[i - 1][j], memo[i][j - 1]);
                }
            }
        }
        return memo[m][n];
    }
 
    static int longestCommonSubSequenceRecursiveSolutionWithCache(char[] str1, char[] str2, int m, int n, int[][] cache) {
        if (m <= 0 || n <= 0) {
            return 0;
        }
        if (cache[m][n] != 0) {
            return cache[m][n];
        }
 
        if (str1[m - 1] == str2[n - 1]) {
            return 1 + longestCommonSubSequenceRecursiveSolutionWithCache(str1, str2, m - 1, n - 1, cache);
        }
 
        return cache[m][n] = Math.max(
                longestCommonSubSequenceRecursiveSolutionWithCache(str1, str2, m, n - 1, cache),
                longestCommonSubSequenceRecursiveSolutionWithCache(str1, str2, m - 1, n, cache)
        );
 
    }
 
    static int longestCommonSubSequenceRecursiveSolution(char[] str1, char[] str2, int m, int n) {
        if (m <= 0 || n <= 0) {
            return 0;
        }
        if (str1[m - 1] == str2[n - 1]) {
            return 1 + longestCommonSubSequenceRecursiveSolution(str1, str2, m - 1, n - 1);
        }
        return Math.max(
                longestCommonSubSequenceRecursiveSolution(str1, str2, m, n - 1),
                longestCommonSubSequenceRecursiveSolution(str1, str2, m - 1, n));
 
    }
 
}

Complete Program

0-1 Knapsack Problem

Given a Set S of n items each with its own value V and Weight W for all 1<=i<=n and maximum knapsack capacity C, compute the maximum value of the items that you can carry. You cannot take fractions of items.
Sample
- val {150, 300, 200}
- wt {1,4,3}

 package com.algo.DP;
 
public class ZeroOneKnapsackProblem {
    
    public static void main(String[] args) {
        int[] value = {150, 300, 200};
        int[] weight = {1, 4, 3};
        int capacity = 4;
        System.out.println(zeroOneKnapsackProblem(value,weight,capacity));
    }
 
    public static int zeroOneKnapsackProblem(int[] value, int[] weight, int capacity) {
        int n = value.length;
        int[][] memo = new int[n + 1][capacity + 1];
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= capacity; j++) {
                if (i == 0 || j == 0) {
                    memo[i][j] = 0;
                } else if (weight[i - 1] > j) {
                    memo[i][j] = memo[i - 1][j];
                }else{
                    memo[i][j]=Math.max(value[i-1]+memo[i-1][j-weight[i-1]],memo[i-1][j]);
                }
            }
        }
        return memo[n][capacity];
    }
}

Dynamic Programming for Java Developers Part 2

Write an efficient program to find the sum of contiguous subarray within a one-dimensional array of numbers that has the largest sum.

4	3	-2	6	7	-10	-10	4	5	9

4 -> 4
7 -> 4,3
5 -> 4,3,-2
11-> 4,3,-2,6
18 -> 4,3,-2,6,7
8 -> 4,3,-2,6,7,-10
-2 -> 4,3,-2,6,7,-10,-10
4 -> 4
9 -> 4,5
18 -> 4,5,9
15-> 4,5,9,-3
19-> 4,5,9,-3,4
26-> 4,5,9,-3,4,7
35->4,5,9,-3,4,7,9

4 -> 4
7 -> 4,3
5 -> 4,3,-2
11-> 4,3,-2,6
18 -> 4,3,-2,6,7
19-> 4,5,9,-3,4
26-> 4,5,9,-3,4,7
35->4,5,9,-3,4,7,9

-3	4	7	9

Kadane's Theorm

Current Best

Overall Best

 package com.algo.DP;
 
public class KadaneAlgorithm {
    public static void main(String[] args) {
        int[] arr = {4, 3, -2, 6, -12, 7, -1, 6};
        System.out.println(maxNumberInArray(arr));
 
    }
 
    public static int maxNumberInArray(int[] arr) {
        int currentMax = arr[0];
        int maxSoFar = arr[0];
 
        for (int i = 1; i < arr.length; i++) {
            currentMax = currentMax + arr[i];
            if (currentMax < arr[i]) {
                currentMax = arr[i];
            }
            if (maxSoFar < currentMax) {
                maxSoFar = currentMax;
            }
        }
        return maxSoFar;
    }
}

The Longest Increasing Subsequence (LIS) problem is to find the length of the longest subsequence of a given sequence such that all elements of the subsequence are sorted in increasing order. For example, the length of LIS for {10, 22, 9, 33, 21, 50, 41, 60, 80} is 6 and LIS is {10, 22, 33, 50, 60, 80}.

Longest Increasing Subsequence

10	22	9	33	21	50	41	60	80	1
1	2	1	3	2	4	4	5	6	1
-	-	-	-	-	-	-	-	-	-
10	10	9	10	10	10	10	10	10	3
	22		22	21	22	22	22	22
			33		33	33	33	33
					50	41	50	50
							60	60
								80

Elements

Count

 package com.algo.DP;
 
import java.util.Arrays;
 
public class LongestIncreasingSequence {
 
    public static void main(String[] args) {
        int[] arr = {10,22,9,33,21,50,41,60,80,1};
        System.out.println(findLIS(arr));
    }
 
 
    public static int findLIS(int[] arr) {
        int[] dp = new int[arr.length];
        dp[0] = 1;
        int maxo = 0;
        for (int i = 1; i < arr.length; i++) {
            int max = 0;
            for (int j = 0; j < i; j++) {
                if (arr[i] > arr[j] && dp[j] > max) {
                        max = dp[j];
                }
                dp[i] = max + 1;
            }
            if (dp[i] > maxo) {
                maxo = dp[i];
            }
            System.out.println(Arrays.toString(dp));
        }
        return maxo;
    }
}

Given a set of non-negative integers, and a value sum, determine if there is a subset of the given set with sum equal to given sum.

example

Input: set[] = {3, 34, 4, 12, 5, 2}, sum = 9
Output: True  
There is a subset (4, 5) with sum 9.

Input: set[] = {3, 34, 4, 12, 5, 2}, sum = 30
Output: False
There is no subset that add up to 30.

Target Sum Subset

1	2	3	4	5	6	7	8	9	10
F	F	F	F	F	F	F	F	F	F
F	F	F	T	F	F	F	F	F	F
F	T	F	T	F	T	F	F	F	F
F	T	F	T	F	T	T	F	T	F
T	T	T	T	T	T	T	T	T	T
T	T	T	T	T	T	T	T	T	T

	0
X	T
4	T
2	T
7	T
1	T
3	T

Input :

Array = {4,5,7,1,3}

Sum=10

 package com.algo.DP;
 
public class TargetSubSets {
 
    public static void main(String[] args) {
        int[] arr = {4, 2, 7, 1, 3};
        int target = 59;
        System.out.println(targetSubset(arr, target));
    }
 
    public static boolean targetSubset(int[] arr, int target) {
        boolean[][] dp = new boolean[arr.length + 1][target + 1];
        for (int i = 0; i < dp.length; i++) {
            for (int j = 0; j < dp[i].length; j++) {
                if (i == 0 && j == 0) {
                    dp[i][j] = true;
                } else if (i == 0) {
                    dp[i][j] = false;
                } else if (j == 0) {
                    dp[i][j] = true;
                } else {
                    if (dp[i - 1][j] == true) {
                        dp[i][j] = true;
                    } else {
                        int val = arr[i - 1];
                        if (val <= j) {
                                if(dp[i-1][j-val]==true){
                                    dp[i][j]=true;
                                }
                        }
                    }
                }
            }
        }
        return dp[arr.length][target];
    }
}

Given a gold mine of n*m dimensions. Each field in this mine contains a positive integer which is the amount of gold in tons. Initially the miner is at first column but can be at any row. He can move only (right->,right up /,right down\) that is from a given cell, the miner can move to the cell diagonally up towards the right or right or diagonally down towards the right. Find out maximum amount of gold he can collect.

Gold Mine Problem

-	-	-	-	-	-
0	1	4	2	8	2
4	3	6	5	0	4
1	2	4	1	4	6
2	0	7	3	2	2
3	1	5	9	2	4
2	7	0	8	5	1

-	-	-	-	-	-
26	24	21	14	12	2
31	26	23	17	6	4
28	27	21	11	10	6
29	25	25	13	8	2
33	26	23	18	6	4
32	30	18	17	9	1

 package com.algo.DP;
 
public class GoldMine {
 
    public static void main(String[] args) {
        int[][] arr = {
                {0, 1, 4, 2, 8, 2},
                {4, 3, 6, 5, 0, 4},
                {1, 2, 4, 1, 4, 6},
                {2, 0, 7, 3, 2, 2},
                {3, 1, 5, 9, 2, 4},
                {2, 7, 0, 8, 5, 1}
        };
 
        System.out.println(goldMine(arr));
    }
 
    public static int goldMine(int[][] arr) {
        int[][] dp = new int[arr.length][arr.length];
        for (int j = arr.length - 1; j >= 0; j--) {
            for (int i = arr.length - 1; i >= 0; i--) {
                if (j == arr.length - 1) {
                    dp[i][j] = arr[i][j];
                } else if (i == 0) {
                    dp[i][j] = arr[i][j] + Math.max(dp[i + 1][j + 1], dp[i][j + 1]);
                } else if (i == arr.length - 1) {
                    dp[i][j] = arr[i][j] + Math.max(dp[i - 1][j + 1], dp[i][j + 1]);
                } else {
                    dp[i][j] = arr[i][j] + Math.max(dp[i][j + 1], Math.max(dp[i - 1][j + 1], dp[i + 1][j + 1]));
                }
            }
        }
        int max = dp[0][0];
        for (int i = 1; i < dp.length; i++) {
            if (dp[i][0] > max) {
                max = dp[i][0];
            }
        }
        return max;
    }
}

The cost of a stock on each day is given in an array, find the max profit that you can make by buying and selling in those days. For example, if the given array is {100, 180, 260, 310, 40, 535, 695}, the maximum profit can earn by buying on day 0, selling on day 3. Again, buy on day 4 and sell on day 6. If the given array of prices is sorted in decreasing order, then profit cannot be earned at all.

Stock Buy and Sell Problem

6

5

4

3

2

1

0

7

1	2	1	2	3	2	3	4	3	4

5

1

2

8

7

6

5

4

3

10

9

 package com.algo.DP;
 
public class StockBuyAndSell {
 
    public static void main(String[] args) {
        int arr[] = {1, 2, 1, 2, 3, 2, 3, 4, 3, 4, 5};
        System.out.println(stockBuyAndSell(arr));
    }
 
    public static int stockBuyAndSell(int arr[]) {
        int bd = 0;
        int sd = 0;
        int profit = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] >= arr[i - 1]) {
                sd++;
            } else {
                profit += arr[sd] - arr[bd];
                bd = sd = i;
            }
        }
        profit += arr[sd] - arr[bd];
        return profit;
    }
}

Given a “2 x n” board and tiles of size “2 x 1”, count the number of ways to tile the given board using the 2 x 1 tiles. A tile can either be placed horizontally i.e., as a 1 x 2 tile or vertically i.e., as 2 x 1 tile.

Tiling Problem

2 x 1

2 x 2

2 x 3

2 x 4

2 x 5

Size	Ways
1	1
2	2
3	3
4	5
5	8

 package com.algo.DP;
 
public class TilingDominoes {
 
    public static void main(String[] args) {
        int n = 3;
        System.out.println(tilingDominoes(n));
 
    }
 
    public static int tilingDominoes(int n) {
        if(n<=2){
            return n;
        }
        int first = 1;
        int second = 2;
        int ways = 0;
        for (int i = 3; i <= n; i++) {
            ways = first + second;
            first = second;
            second = ways;
        }
        return ways;
    }
}

Given a rod of length n inches and an array of prices that includes prices of all pieces of size smaller than n. Determine the maximum value obtainable by cutting up the rod and selling the pieces. For example, if the length of the rod is 8 and the values of different pieces are given as the following, then the maximum obtainable value is 22 (by cutting in two pieces of lengths 2 and 6)

length   | 1   2   3   4   5   6   7   8  
--------------------------------------------
price    | 1   5   8   9  10  17  17  20

Rod Cutting Problem

Cost	N	1	5	8	9	10	17	17	20
Wood Length	0	1	2	3	4	5	6	7	8
Best Cost	0	1	5	8	10	13	17	18	22
Combination (Best)	0	1- 0	2-0	3-0	2-2	2-3	6-0	6-1	2-6

 package com.algo.DP;
 
import java.util.Arrays;
 
public class RodCutting {
 
    public static void main(String[] args) {
        int[] prices = {1, 5, 8, 9, 10};
        System.out.println(rodCutting(prices));
    }
 
    public static int rodCutting(int[] prices) {
        int[] np = new int[prices.length + 1];
        for (int i = 0; i < prices.length; i++) {
            np[i + 1] = prices[i];
        }
        int[] dp = new int[np.length];
        dp[0] = 0;
        dp[1] = np[1];
        for (int i = 2; i < dp.length; i++) {
            dp[i] = np[i];
            int li = 1;
            int ri = i - 1;
            while (li <= ri) {
                if (dp[i] < dp[li] + dp[ri]) {
                    dp[i] = dp[li] + dp[ri];
                }
                li++;
                ri--;
            }
        }
        System.out.println(Arrays.toString(dp));
        return dp[dp.length - 1];
    }
}

The following is a description of the instance of this famous puzzle involving n=2 eggs and a building with k=36 floors.
Suppose that we wish to know which stories in a 36-story building are safe to drop eggs from, and which will cause the eggs to break on landing. We make a few assumptions:
…..An egg that survives a fall can be used again.
…..A broken egg must be discarded.
…..The effect of a fall is the same for all eggs.
…..If an egg breaks when dropped, then it would break if dropped from a higher floor.
…..If an egg survives a fall then it would survive a shorter fall.
…..It is not ruled out that the first-floor windows break eggs, nor is it ruled out that the 36th-floor do not cause an egg to break.
If only one egg is available and we wish to be sure of obtaining the right result, the experiment can be carried out in only one way. Drop the egg from the first-floor window; if it survives, drop it from the second-floor window. Continue upward until it breaks. In the worst case, this method may require 36 droppings. Suppose 2 eggs are available. What is the least number of egg-droppings that is guaranteed to work in all cases?

7 f

3 e

Here we need to find the minimum attempts in which we will find the critical floor. Critical floor (i.e from where egg will break).

Base cases

f=0 -> 0

f=1-> 1

e=0 -> X

e=1 -> f

Egg Dropping Problem

e|f

Survived

Broke

e|f-k

e-1|k-1

kth Floor

7 floors 3 eggs

	0	1	2	3	4	5	6	7
0	-	-	-	-	-	-	-	-
1	0	1	2	3	4	5	6	7
2	0	1	2	2	3	3	3	4
3	0	1	2	2	3	3	3	3

Floors

Eggs

3,3,3,2,3,3,3

2 E/ 2F

1 F

2 F

Broke

Survive

Broke

Survive

1E/ 0F = 0

2 E/ 1F = 1

1 E/ 1F = 1

2 E/ 0F = 0

Max(1,0)=1

Max(0,1)=1

Min(1,1)+1=2

2E|3F

2E|0F =0

1E|2F=2

2E|1F =1

1E|1F =1

2E|2F=2

1E|0F=0

1F

2F

3F

Broke

Survive

Broke

Survive

Broke

Survive

Max(2,0)=2

Max(1,1)=1

Max(0,2)=2

Min(2,1,2)+1=2

 package com.algo.DP;
 
public class EggDropping {
 
    public static void main(String[] args) {
        int floors = 7;
        int eggs = 3;
        System.out.println(eggDropping(eggs, floors));;
    }
 
    public static int eggDropping(int n, int k) {
        int[][] dp = new int[n + 1][k + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= k; j++) {
                if (i == 1) {
                    dp[i][j] = j;
                } else if (j == 1) {
                    dp[i][j] = 1;
                } else {
                    int min = Integer.MAX_VALUE;
                    for (int mj = j - 1, pj = 0; mj >= 0; mj--, pj++) {
                        int v1 = dp[i][mj];// egg survive
                        int v2 = dp[i - 1][pj];// egg breaks
                        int val = Math.max(v1, v2);
                        min = Math.min(val, min);
                    }
                    dp[i][j] = min + 1;
                }
            }
        }
        return dp[n][k];
    }
}

	public static int fib(int n) {
	if (n < 2)
	return n;
	return fib(n - 1) + fib(n - 2);
	}

	public static int fib(int n, int[] cache) {
	if (n < 2) {
	return n;
	}
	if (cache[n] != 0) {
	return cache[n];
	}
	return cache[n] = fib(n - 1, cache) + fib(n - 2, cache);
	}

	public static int fibTabulation(int n) {
	int[] cache = new int[n + 1];
	cache[0] = 0;
	cache[1] = 1;
	for (int i = 2; i < cache.length; i++) {
	cache[i] = cache[i - 1] + cache[i - 2];
	}
	return cache[n];
	}

	public static int fibEffec(int n) {
	if(n<2){
	return n;
	}
	int first = 0;
	int second = 1;
	int sum = 0;
	for (int i = 2; i < n + 1; i++) {
	sum = first + second;
	first = second;
	second = sum;
	}
	return sum;
	}

	package com.algo.DP;

	public class Demo1 {

	public static void main(String[] args) {
	int n = 4;
	int[] cache = new int[n + 1];
	System.out.println(fib(n));
	System.out.println(fib(n, cache));
	System.out.println(fibTabulation(n));
	System.out.println(fibEffec(n));
	}

	public static int fibEffec(int n) {
	if(n<2){
	return n;
	}
	int first = 0;
	int second = 1;
	int sum = 0;
	for (int i = 2; i < n + 1; i++) {
	sum = first + second;
	first = second;
	second = sum;
	}
	return sum;
	}

	public static int fibTabulation(int n) {
	int[] cache = new int[n + 1];
	cache[0] = 0;
	cache[1] = 1;
	for (int i = 2; i < cache.length; i++) {
	cache[i] = cache[i - 1] + cache[i - 2];
	}
	return cache[n];
	}

	public static int fib(int n) {
	if (n < 2)
	return n;
	return fib(n - 1) + fib(n - 2);
	}

	public static int fib(int n, int[] cache) {
	if (n < 2) {
	return n;
	}
	if (cache[n] != 0) {
	return cache[n];
	}
	return cache[n] = fib(n - 1, cache) + fib(n - 2, cache);
	}
	}

	static int stairCaseSolution(int n) {
	if (n < 0) {
	return 0;
	}
	if (n == 0) {
	return 1;
	}
	return stairCaseSolution(n - 1) + stairCaseSolution(n - 2);
	}

	static int stairCaseSolution(int n, int[] arr) {
	if (n < 0) {
	return 0;
	}
	if (n == 0) {
	return 1;
	}
	if (arr[n] != 0) {
	return arr[n];
	}
	return arr[n] = stairCaseSolution(n - 1, arr) + stairCaseSolution(n - 2, arr);
	}

	static int stairCaseBottomUpSolution(int n, int[] arr) {
	arr[0] = 1;
	arr[1] = 1;
	for (int i = 2; i <= n; i++) {
	arr[i] = arr[i - 1] + arr[i - 2];
	}
	return arr[n];
	}

	static int stairCaseBottomUpSolutionWithoutCache(int n) {
	int first = 1, second = 1, sum = 0;

	for (int i = 2; i <= n; i++) {
	sum = first + second;
	first = second;
	second = sum;

	}
	return sum;
	}

	static int robCache(int[] arr, int n, int[] cache) {
	if (n < 0) {
	return 0;
	}
	if (cache[n] != 0) {
	return cache[n];
	}
	int ith_house_selected = robCache(arr, n - 2, cache) + arr[n];
	int ith_house_not_selected = robCache(arr, n - 1, cache);
	return cache[n] = Math.max(ith_house_selected, ith_house_not_selected);
	}

	static int houseRobberBottomUpSolution(int[] arr, int[] cache) {
	cache[0] = arr[0];
	cache[1] = Math.max(arr[0], arr[1]);
	for (int i = 2; i < arr.length; i++) {
	cache[i]=Math.max(cache[i-1],cache[i-2]+arr[i]);
	}
	return cache[arr.length-1];
	}

	static int houseRobberBottomUpSolutionWithoutCache(int[] arr) {
	int prev2 = arr[0];
	int prev1 = Math.max(arr[0], arr[1]);
	for (int i = 2; i < arr.length; i++) {
	int tmp = prev1;
	prev1 = Math.max(prev2 + arr[i], prev1);
	prev2 = tmp;
	}
	return prev1;
	}

	package com.algo.DP;

	public class HouseRobberProblem {

	public static void main(String[] args) {

	int[] arr = {2, 45, 8, 7, 98, 24};
	int[] cache = new int[arr.length + 1];
	System.out.println(rob(arr, arr.length - 1));
	System.out.println(robCache(arr, arr.length - 1, cache));
	System.out.println(houseRobberBottomUpSolution(arr,cache));
	System.out.println(houseRobberBottomUpSolutionWithoutCache(arr));

	}

	static int rob(int[] arr, int n) {

	if (n < 0) {
	return 0;
	}
	int ith_house_selected = rob(arr, n - 2) + arr[n];
	int ith_house_not_selected = rob(arr, n - 1);
	return Math.max(ith_house_selected, ith_house_not_selected);
	}

	static int robCache(int[] arr, int n, int[] cache) {
	if (n < 0) {
	return 0;
	}
	if (cache[n] != 0) {
	return cache[n];
	}
	int ith_house_selected = robCache(arr, n - 2, cache) + arr[n];
	int ith_house_not_selected = robCache(arr, n - 1, cache);
	return cache[n] = Math.max(ith_house_selected, ith_house_not_selected);
	}

	static int houseRobberBottomUpSolution(int[] arr, int[] cache) {
	cache[0] = arr[0];
	cache[1] = Math.max(arr[0], arr[1]);
	for (int i = 2; i < arr.length; i++) {
	cache[i]=Math.max(cache[i-1],cache[i-2]+arr[i]);
	}
	return cache[arr.length-1];
	}

	static int houseRobberBottomUpSolutionWithoutCache(int[] arr) {
	int prev2 = arr[0];
	int prev1 = Math.max(arr[0], arr[1]);
	for (int i = 2; i < arr.length; i++) {
	int tmp = prev1;
	prev1 = Math.max(prev2 + arr[i], prev1);
	prev2 = tmp;
	}
	return prev1;
	}
	}

	static int longestCommonSubString(char[] str1, char[] str2, int m, int n, int lcsCount) {
	if (m <= 0 \|\| n <= 0) {
	return lcsCount;
	}
	int lcsCount1 = lcsCount;
	if (str1[m - 1] == str2[n - 1]) {
	lcsCount1 = longestCommonSubString(str1, str2, m - 1, n - 1, lcsCount + 1);
	}
	int lcsCount2 = longestCommonSubString(str1, str2, m, n - 1, 0);
	int lcsCount3 = longestCommonSubString(str1, str2, m - 1, n, 0);
	return Math.max(lcsCount1, Math.max(lcsCount2, lcsCount3));
	}

	static int longestCommonSubStringWithCaching(char[] str1, char[] str2, int m, int n, int lcsCount, int cache[][][]) {
	if (m <= 0 \|\| n <= 0) {
	return lcsCount;
	}
	if (cache[m][n][lcsCount] != 0) {
	return cache[m][n][lcsCount];
	}
	int lcsCount1 = lcsCount;
	if (str1[m - 1] == str2[n - 1]) {
	lcsCount1 = longestCommonSubStringWithCaching(str1, str2, m - 1, n - 1, lcsCount + 1, cache);
	}
	int lcsCount2 = longestCommonSubStringWithCaching(str1, str2, m, n - 1, 0, cache);
	int lcsCount3 = longestCommonSubStringWithCaching(str1, str2, m - 1, n, 0, cache);
	return cache[m][n][lcsCount] = Math.max(lcsCount1, Math.max(lcsCount2, lcsCount3));

	}

	static int longestCommonSubStringBottomUpSolution(char[] str1, char[] str2, int m, int n) {
	int result = 0;
	int[][] memo = new int[m + 1][n + 1];

	for (int i = 0; i <= m; i++) {
	for (int j = 0; j <= n; j++) {
	if (i == 0 \|\| j == 0) {
	memo[i][j] = 0;
	} else if (str1[i - 1] == str2[j - 1]) {
	memo[i][j] = memo[i - 1][j - 1] + 1;
	result = Math.max(memo[i][j], result);
	} else {
	memo[i][j] = 0;
	}
	}
	}
	return result;
	}

	package com.algo.DP;

	public class LongestCommonSubStringProblem {

	public static void main(String[] args) {
	String str = "JavaProgrammingLanguage";
	String str2 = "JavaLanguage";
	// String str = "JavaProgram";
	// String str2 = "JavaProgram";
	int m = str.length();
	int n = str2.length();
	int[][][] cache = new int[m + 1][n + 1][Math.max(m, n) + 1];
	System.out.println(longestCommonSubString(str.toCharArray(), str2.toCharArray(), str.length(), str2.length(), 0));
	System.out.println(longestCommonSubStringWithCaching(str.toCharArray(), str2.toCharArray(), str.length(), str2.length(), 0, cache));
	System.out.println(longestCommonSubStringBottomUpSolution(str.toCharArray(), str2.toCharArray(), str.length(), str2.length()));
	}


	static int longestCommonSubStringBottomUpSolution(char[] str1, char[] str2, int m, int n) {
	int result = 0;
	int[][] memo = new int[m + 1][n + 1];
	for (int i = 0; i <= m; i++) {
	for (int j = 0; j <= n; j++) {
	if (i == 0 \|\| j == 0) {
	memo[i][j] = 0;
	} else if (str1[i - 1] == str2[j - 1]) {
	memo[i][j] = memo[i - 1][j - 1] + 1;
	result = Math.max(memo[i][j], result);
	} else {
	memo[i][j] = 0;
	}
	}
	}
	return result;
	}

	static int longestCommonSubStringWithCaching(char[] str1, char[] str2, int m, int n, int lcsCount, int cache[][][]) {
	if (m <= 0 \|\| n <= 0) {
	return lcsCount;
	}
	if (cache[m][n][lcsCount] != 0) {
	return cache[m][n][lcsCount];
	}
	int lcsCount1 = lcsCount;
	if (str1[m - 1] == str2[n - 1]) {
	lcsCount1 = longestCommonSubStringWithCaching(str1, str2, m - 1, n - 1, lcsCount + 1, cache);
	}
	int lcsCount2 = longestCommonSubStringWithCaching(str1, str2, m, n - 1, 0, cache);
	int lcsCount3 = longestCommonSubStringWithCaching(str1, str2, m - 1, n, 0, cache);
	return cache[m][n][lcsCount] = Math.max(lcsCount1, Math.max(lcsCount2, lcsCount3));

	}

	static int longestCommonSubString(char[] str1, char[] str2, int m, int n, int lcsCount) {
	if (m <= 0 \|\| n <= 0) {
	return lcsCount;
	}
	int lcsCount1 = lcsCount;
	if (str1[m - 1] == str2[n - 1]) {
	lcsCount1 = longestCommonSubString(str1, str2, m - 1, n - 1, lcsCount + 1);
	}
	int lcsCount2 = longestCommonSubString(str1, str2, m, n - 1, 0);
	int lcsCount3 = longestCommonSubString(str1, str2, m - 1, n, 0);
	return Math.max(lcsCount1, Math.max(lcsCount2, lcsCount3));
	}
	}

	static int longestCommonSubSequenceRecursiveSolution(char[] str1, char[] str2, int m, int n) {
	if (m <= 0 \|\| n <= 0) {
	return 0;
	}
	if (str1[m - 1] == str2[n - 1]) {
	return 1 + longestCommonSubSequenceRecursiveSolution(str1, str2, m - 1, n - 1);
	}
	return Math.max(
	longestCommonSubSequenceRecursiveSolution(str1, str2, m, n - 1),
	longestCommonSubSequenceRecursiveSolution(str1, str2, m - 1, n));

	}

	static int longestCommonSubSequenceBottomUpSolution(char[] str1, char[] str2, int m, int n) {
	int[][] memo = new int[m + 1][n + 1];
	for (int i = 0; i <= m; i++) {
	for (int j = 0; j <= n; j++) {
	if (i == 0 \|\| j == 0) {
	memo[i][j] = 0;
	} else if (str1[i - 1] == str2[j - 1]) {
	memo[i][j] = memo[i - 1][j - 1] + 1;
	} else {
	memo[i][j] = Math.max(memo[i - 1][j], memo[i][j - 1]);
	}
	}
	}
	return memo[m][n];
	}

	package com.algo.DP;

	public class LongestCommonSubSequenceProblem {

	public static void main(String[] args) {
	String str = "Javaaid";
	String str2 = "Javaid";
	int m = str.length();
	int n = str2.length();
	int[][] cache = new int[m + 1][n + 1];
	// System.out.println(longestCommonSubSequenceRecursiveSolution(str.toCharArray(), str2.toCharArray(), m, n));
	// System.out.println(longestCommonSubSequenceRecursiveSolutionWithCache(str.toCharArray(), str2.toCharArray(), m, n, cache));
	System.out.println(longestCommonSubSequenceBottomUpSolution(str.toCharArray(), str2.toCharArray(), m, n));
	}

	static int longestCommonSubSequenceBottomUpSolution(char[] str1, char[] str2, int m, int n) {
	int[][] memo = new int[m + 1][n + 1];
	for (int i = 0; i <= m; i++) {
	for (int j = 0; j <= n; j++) {
	if (i == 0 \|\| j == 0) {
	memo[i][j] = 0;
	} else if (str1[i - 1] == str2[j - 1]) {
	memo[i][j] = memo[i - 1][j - 1] + 1;
	} else {
	memo[i][j] = Math.max(memo[i - 1][j], memo[i][j - 1]);
	}
	}
	}
	return memo[m][n];
	}

	static int longestCommonSubSequenceRecursiveSolutionWithCache(char[] str1, char[] str2, int m, int n, int[][] cache) {
	if (m <= 0 \|\| n <= 0) {
	return 0;
	}
	if (cache[m][n] != 0) {
	return cache[m][n];
	}

	if (str1[m - 1] == str2[n - 1]) {
	return 1 + longestCommonSubSequenceRecursiveSolutionWithCache(str1, str2, m - 1, n - 1, cache);
	}

	return cache[m][n] = Math.max(
	longestCommonSubSequenceRecursiveSolutionWithCache(str1, str2, m, n - 1, cache),
	longestCommonSubSequenceRecursiveSolutionWithCache(str1, str2, m - 1, n, cache)
	);

	}

	static int longestCommonSubSequenceRecursiveSolution(char[] str1, char[] str2, int m, int n) {
	if (m <= 0 \|\| n <= 0) {
	return 0;
	}
	if (str1[m - 1] == str2[n - 1]) {
	return 1 + longestCommonSubSequenceRecursiveSolution(str1, str2, m - 1, n - 1);
	}
	return Math.max(
	longestCommonSubSequenceRecursiveSolution(str1, str2, m, n - 1),
	longestCommonSubSequenceRecursiveSolution(str1, str2, m - 1, n));

	}

	}

Dynamic Programming

Java 9

More from Pulkit Pushkarna

	package com.algo.DP;

	public class ZeroOneKnapsackProblem {

	public static void main(String[] args) {
	int[] value = {150, 300, 200};
	int[] weight = {1, 4, 3};
	int capacity = 4;
	System.out.println(zeroOneKnapsackProblem(value,weight,capacity));
	}

	public static int zeroOneKnapsackProblem(int[] value, int[] weight, int capacity) {
	int n = value.length;
	int[][] memo = new int[n + 1][capacity + 1];
	for (int i = 0; i <= n; i++) {
	for (int j = 0; j <= capacity; j++) {
	if (i == 0 \|\| j == 0) {
	memo[i][j] = 0;
	} else if (weight[i - 1] > j) {
	memo[i][j] = memo[i - 1][j];
	}else{
	memo[i][j]=Math.max(value[i-1]+memo[i-1][j-weight[i-1]],memo[i-1][j]);
	}
	}
	}
	return memo[n][capacity];
	}
	}

	package com.algo.DP;

	public class KadaneAlgorithm {
	public static void main(String[] args) {
	int[] arr = {4, 3, -2, 6, -12, 7, -1, 6};
	System.out.println(maxNumberInArray(arr));

	}

	public static int maxNumberInArray(int[] arr) {
	int currentMax = arr[0];
	int maxSoFar = arr[0];

	for (int i = 1; i < arr.length; i++) {
	currentMax = currentMax + arr[i];
	if (currentMax < arr[i]) {
	currentMax = arr[i];
	}
	if (maxSoFar < currentMax) {
	maxSoFar = currentMax;
	}
	}
	return maxSoFar;
	}
	}

10	22	9	33	21	50	41	60	80	1
1	2	1	3	2	4	4	5	6	1
-	-	-	-	-	-	-	-	-	-
10	10	9	10	10	10	10	10	10	3
	22		22	21	22	22	22	22
			33		33	33	33	33
					50	41	50	50
							60	60
								80

	package com.algo.DP;

	import java.util.Arrays;

	public class LongestIncreasingSequence {

	public static void main(String[] args) {
	int[] arr = {10,22,9,33,21,50,41,60,80,1};
	System.out.println(findLIS(arr));
	}


	public static int findLIS(int[] arr) {
	int[] dp = new int[arr.length];
	dp[0] = 1;
	int maxo = 0;
	for (int i = 1; i < arr.length; i++) {
	int max = 0;
	for (int j = 0; j < i; j++) {
	if (arr[i] > arr[j] && dp[j] > max) {
	max = dp[j];
	}
	dp[i] = max + 1;
	}
	if (dp[i] > maxo) {
	maxo = dp[i];
	}
	System.out.println(Arrays.toString(dp));
	}
	return maxo;
	}
	}

1	2	3	4	5	6	7	8	9	10
F	F	F	F	F	F	F	F	F	F
F	F	F	T	F	F	F	F	F	F
F	T	F	T	F	T	F	F	F	F
F	T	F	T	F	T	T	F	T	F
T	T	T	T	T	T	T	T	T	T
T	T	T	T	T	T	T	T	T	T

	package com.algo.DP;

	public class TargetSubSets {

	public static void main(String[] args) {
	int[] arr = {4, 2, 7, 1, 3};
	int target = 59;
	System.out.println(targetSubset(arr, target));
	}

	public static boolean targetSubset(int[] arr, int target) {
	boolean[][] dp = new boolean[arr.length + 1][target + 1];
	for (int i = 0; i < dp.length; i++) {
	for (int j = 0; j < dp[i].length; j++) {
	if (i == 0 && j == 0) {
	dp[i][j] = true;
	} else if (i == 0) {
	dp[i][j] = false;
	} else if (j == 0) {
	dp[i][j] = true;
	} else {
	if (dp[i - 1][j] == true) {
	dp[i][j] = true;
	} else {
	int val = arr[i - 1];
	if (val <= j) {
	if(dp[i-1][j-val]==true){
	dp[i][j]=true;
	}
	}
	}
	}
	}
	}
	return dp[arr.length][target];
	}
	}

-	-	-	-	-	-
26	24	21	14	12	2
31	26	23	17	6	4
28	27	21	11	10	6
29	25	25	13	8	2
33	26	23	18	6	4
32	30	18	17	9	1

	package com.algo.DP;

	public class GoldMine {

	public static void main(String[] args) {
	int[][] arr = {
	{0, 1, 4, 2, 8, 2},
	{4, 3, 6, 5, 0, 4},
	{1, 2, 4, 1, 4, 6},
	{2, 0, 7, 3, 2, 2},
	{3, 1, 5, 9, 2, 4},
	{2, 7, 0, 8, 5, 1}
	};

	System.out.println(goldMine(arr));
	}

	public static int goldMine(int[][] arr) {
	int[][] dp = new int[arr.length][arr.length];
	for (int j = arr.length - 1; j >= 0; j--) {
	for (int i = arr.length - 1; i >= 0; i--) {
	if (j == arr.length - 1) {
	dp[i][j] = arr[i][j];
	} else if (i == 0) {
	dp[i][j] = arr[i][j] + Math.max(dp[i + 1][j + 1], dp[i][j + 1]);
	} else if (i == arr.length - 1) {
	dp[i][j] = arr[i][j] + Math.max(dp[i - 1][j + 1], dp[i][j + 1]);
	} else {
	dp[i][j] = arr[i][j] + Math.max(dp[i][j + 1], Math.max(dp[i - 1][j + 1], dp[i + 1][j + 1]));
	}
	}
	}
	int max = dp[0][0];
	for (int i = 1; i < dp.length; i++) {
	if (dp[i][0] > max) {
	max = dp[i][0];
	}
	}
	return max;
	}
	}

	package com.algo.DP;

	public class StockBuyAndSell {

	public static void main(String[] args) {
	int arr[] = {1, 2, 1, 2, 3, 2, 3, 4, 3, 4, 5};
	System.out.println(stockBuyAndSell(arr));
	}

	public static int stockBuyAndSell(int arr[]) {
	int bd = 0;
	int sd = 0;
	int profit = 0;
	for (int i = 1; i < arr.length; i++) {
	if (arr[i] >= arr[i - 1]) {
	sd++;
	} else {
	profit += arr[sd] - arr[bd];
	bd = sd = i;
	}
	}
	profit += arr[sd] - arr[bd];
	return profit;
	}
	}

	package com.algo.DP;

	public class TilingDominoes {

	public static void main(String[] args) {
	int n = 3;
	System.out.println(tilingDominoes(n));

	}

	public static int tilingDominoes(int n) {
	if(n<=2){
	return n;
	}
	int first = 1;
	int second = 2;
	int ways = 0;
	for (int i = 3; i <= n; i++) {
	ways = first + second;
	first = second;
	second = ways;
	}
	return ways;
	}
	}