added dynamic programming chapter

Author: Vishal023

.gitignore

@@ -1 +1,3 @@
-/Practice
+/Practice
+.idea/
+SummerTrainingGFG.iml

DynamicProgramming/FibonacciNumber.java

@@ -0,0 +1,45 @@
+package SummerTrainingGFG.DynamicProgramming;
+
+import java.util.Arrays;
+/**
+ * @author Vishal Singh
+ */
+public class FibonacciNumber {
+    /*
+    * Idea is to save those values which you have already computed
+    * Memoization Top-Down */
+    static int[] memoize;
+    static int fibMemoization(int n){
+        if (memoize[n] == -1){
+            int res;
+            if (n == 0 || n == 1){
+                res = n;
+            }else {
+                res = fibMemoization(n-1) + fibMemoization(n-2);
+            }
+            memoize[n] = res;
+        }
+        return memoize[n];
+    }
+    /*
+    * Faster than memoization
+    * Tabulations Bottom - Up*/
+    static int fibTabulation(int n){
+        int[] f = new int[n+1];
+        f[0] = 0;
+        f[1] = 1;
+        for (int i = 2; i <= n; i++) {
+            f[i] = f[i-1] + f[i-2];
+        }
+        return f[n];
+    }
+    public static void main(String[] args) {
+        int n = 6;
+        memoize = new int[n+1];
+        Arrays.fill(memoize,-1);
+        System.out.println(fibMemoization(n));
+
+        System.out.println(fibTabulation(6));
+
+    }
+}

DynamicProgramming/LongestCommonSubsequence.java

@@ -0,0 +1,87 @@
+package SummerTrainingGFG.DynamicProgramming;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+/**
+ * @author Vishal Singh
+ */
+public class LongestCommonSubsequence {
+    /*
+     * Subsequence is picking some characters in same order but may not be contiguous
+     * Substring means need to pick continuous characters
+     * Subsequence of CDA -> "","C","D","A","CD","CA","DA","CDA"
+     * 2^N POSSIBLE SUBSEQUENCE
+     * Substring of CDA -> "","C","D","A","CD","DA","CDA"
+     * LCS Of "ABCDGH" and "AEDFHR" is "ADH" length = 3
+     * */
+
+    /*
+     * RECURSIVE SOLUTION*/
+    static int lcs(String s1, String s2, int m, int n) {
+        if (m == 0 || n == 0) {
+            return 0;
+        }
+        if (s1.charAt(m - 1) == s2.charAt(n - 1)) {
+            return 1 + lcs(s1, s2, m - 1, n - 1);
+        } else {
+            return Math.max(lcs(s1, s2, m - 1, n), lcs(s1, s2, m, n - 1));
+        }
+    }
+
+    /*
+     * MEMOIZATION - Theta(m*n)*/
+    static int[][] memoize;
+
+    static int lcsMemoize(String s1, String s2, int m, int n) {
+        if (memoize[m][n] != -1) {
+            return memoize[m][n];
+        }
+        if (m == 0 || n == 0) {
+            memoize[m][n] = 0;
+        }
+        if (s1.charAt(m - 1) == s2.charAt(n - 1)) {
+            memoize[m][n] = 1 + lcs(s1, s2, m - 1, n - 1);
+        } else {
+            memoize[m][n] = Math.max(lcs(s1, s2, m - 1, n), lcs(s1, s2, m, n - 1));
+        }
+        return memoize[m][n];
+    }
+    /*
+    * TABULATION - Theta(m*n)*/
+    static int lcsTabulation(String s1,String s2){
+        int m = s1.length();
+        int n = s2.length();
+        int[][] dp = new int[m+1][n+1];
+        for (int i = 0; i <= m; i++) {
+            dp[i][0] = 0;
+        }
+        for (int i = 0; i <= n; i++) {
+            dp[0][i] = 0;
+        }
+        for (int i = 1; i <= m; i++) {
+            for (int j = 1; j <= n; j++) {
+                if (s1.charAt(i-1) == s2.charAt(j-1)){
+                    dp[i][j] = 1 + dp[i-1][j-1];
+                }else {
+                    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]);
+                }
+            }
+        }
+        return dp[m][n];
+    }
+    public static void main(String[] args) {
+        System.out.println(lcs("axyz", "baz", 4, 3));
+
+        int m = 4;
+        int n = 3;
+        memoize = new int[m + 1][n + 1];
+        for (int[] row : memoize) {
+            Arrays.fill(row, -1);
+        }
+        System.out.println(lcsMemoize("axyz","baz",m,n));
+
+        System.out.println(lcsTabulation("axyz","baz"));
+
+    }
+}