Merge pull request #70 from Jer3myYu/java-solutions-dynamic-programming

Java Chapter 15: Dynamic Programming

Author: Destiny-02

java/Dynamic Programming/ClimbingStairsBottomUp.java

@@ -0,0 +1,17 @@
+public class ClimbingStairsBottomUp {
+    public int climbingStairsBottomUp(int n) {
+        if (n <= 2) {
+            return n;
+        }
+        int[] dp = new int[n + 1];
+        // Base cases.
+        dp[1] = 1;
+        dp[2] = 2;
+        // Starting from step 3, calculate the number of ways to reach each 
+        // step until the n-th step.
+        for (int i = 3; i < n + 1; i++) {
+            dp[i] = dp[i - 1] + dp[i - 2];
+        }
+        return dp[n];
+    }
+}

java/Dynamic Programming/ClimbingStairsBottomUpOptimized.java

@@ -0,0 +1,18 @@
+public record ClimbingStairsBottomUpOptimized() {
+    public int climbingStairsBottomUpOptimized(int n) {
+        if (n <= 2) {
+            return n;
+        }
+        // Set 'oneStepBefore' and 'twoStepsBefore' as the base cases.
+        int oneStepBefore = 2;
+        int twoStepsBefore = 1;
+        for (int i = 3; i < n + 1; i++) {
+            // Calculate the number of ways to reach the current step.
+            int current = oneStepBefore + twoStepsBefore;
+            // Update the values for the next iteration.
+            twoStepsBefore = oneStepBefore;
+            oneStepBefore = current;
+        }
+        return oneStepBefore;
+    }
+}

java/Dynamic Programming/ClimbingStairsTopDown.java

@@ -0,0 +1,21 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class ClimbingStairsTopDown {
+    Map<Integer, Integer> memo = new HashMap<>();
+
+    public int climbingStairsTopDown(int n) {
+        // Base cases: With a 1-step staircase, there's only one way to 
+        // climb it. With a 2-step staircase, there are two ways to climb it.
+        if (n <= 2) {
+            return n;
+        }
+        if (memo.containsKey(n)) {
+            return memo.get(n);
+        }
+        // The number of ways to climb to the n-th step is equal to the sum 
+        // of the number  of ways to climb to step n - 1 and to n - 2.
+        memo.put(n, climbingStairsTopDown(n - 1) + climbingStairsTopDown(n - 2));
+        return memo.get(n);
+    }
+}

java/Dynamic Programming/Knapsack.java

@@ -0,0 +1,26 @@
+public class Knapsack {
+    public int knapsack(int cap, int[] weights, int[] values) {
+        int n = values.length;
+        // Base case: Set the first column and last row to 0 by
+        // initializing the entire DP table to 0.
+        int[][] dp = new int[n + 1][cap + 1];
+
+        // Populate the DP table.
+        for (int i = n - 1; i >= 0; i--) {
+            for (int c = 1; c < cap + 1; c++) {
+                // If the item 'i' fits in the current knapsack capacity,
+                // the maximum value at 'dp[i][c]' is the largest of either:
+                // 1. The maximum value if we include item 'i'.
+                // 2. The maximum value if we exclude item 'i'.
+                if (weights[i] <= c) {
+                    dp[i][c] = Math.max(values[i] + dp[i + 1][c - weights[i]], dp[i + 1][c]);
+                }
+                // If it doesn't fit, we have to exclude it.
+                else {
+                    dp[i][c] = dp[i + 1][c];
+                }
+            }
+        }
+        return dp[0][cap];
+    }
+}

java/Dynamic Programming/KnapsackOptimized.java

@@ -0,0 +1,30 @@
+public class KnapsackOptimized {
+    public int knapsackOptimized(int cap, int[] weights, int[] values) {
+        int n = values.length;
+        // Initialize 'prevRow' as the DP values of the row below the
+        // current row.
+        int[] prevRow = new int[cap + 1];
+        for (int i = n - 1; i >= 0; i--) {
+            // Set the first cell of the 'currRow' to 0 to set the base
+            // case for this row. This is done by initializing the entire
+            // row to 0.
+            int[] currRow = new int[cap + 1];
+            for (int c = 1; c < cap + 1; c++) {
+                // If item 'i' fits in the current knapsack capacity, the
+                // maximum value at 'currRow[c]' is the largest of either:
+                // 1. The maximum value if we include item 'i'.
+                // 2. The maximum value if we exclude item 'i'.
+                if (weights[i] <= c) {
+                    currRow[c] = Math.max(values[i] + prevRow[c - weights[i]], prevRow[c]);
+                }
+                // If item 'i' doesn't fit, we exclude it.
+                else {
+                    currRow[c] = prevRow[c];
+                }
+            }
+            // Set 'prevRow' to 'currRow' values for the next iteration.
+            prevRow = currRow;
+        }
+        return prevRow[cap];
+    }
+}

java/Dynamic Programming/LargestSquareInAMatrix.java

@@ -0,0 +1,40 @@
+public class LargestSquareInAMatrix {
+    public int largestSquareInAMatrix(int[][] matrix) {
+        if (matrix == null || matrix.length == 0 || matrix[0] == null || matrix[0].length == 0) {
+            return 0;
+        }
+        int m = matrix.length;
+        int n = matrix[0].length;
+        int[][] dp = new int[m][n];
+        int maxLen = 0;
+        // Base case: If a cell in row 0 is 1, the largest square ending there has a
+        // length of 1.
+        for (int j = 0; j < n; j++) {
+            if (matrix[0][j] == 1) {
+                dp[0][j] = 1;
+                maxLen = 1;
+            }
+        }
+        // Base case: If a cell in column 0 is 1, the largest square ending there has
+        // a length of 1.
+        for (int i = 0; i < m; i++) {
+            if (matrix[i][0] == 1) {
+                dp[i][0] = 1;
+                maxLen = 1;
+            }
+        }
+        // Populate the rest of the DP table.
+        for (int i = 1; i < m; i++) {
+            for (int j = 1; j < n; j++) {
+                if (matrix[i][j] == 1) {
+                    // The length of the largest square ending here is determined by
+                    // the smallest square ending at the neighboring cells (left,
+                    // top-left, top), plus 1 to include this cell.
+                    dp[i][j] = 1 + Math.min(dp[i - 1][j], Math.min(dp[i - 1][j - 1], dp[i][j - 1]));
+                }
+                maxLen = Math.max(maxLen, dp[i][j]);
+            }
+        }
+        return maxLen * maxLen;
+    }
+}

java/Dynamic Programming/LargestSquareInAMatrixOptimized.java

@@ -0,0 +1,32 @@
+public class LargestSquareInAMatrixOptimized {
+    public int largestSquareInAMatrixOptimized(int[][] matrix) {
+        if (matrix == null || matrix.length == 0 || matrix[0] == null || matrix[0].length == 0) {
+            return 0;
+        }
+        int m = matrix.length;
+        int n = matrix[0].length;
+        int[] prevRow = new int[n];
+        int maxLen = 0;
+        // Iterate through the matrix.
+        for (int i = 0; i < m; i++) {
+            int[] currRow = new int[n];
+            for (int j = 0; j < n; j++) {
+                // Base cases: if we’re in row 0 or column 0, the largest square ending
+                // here has a length of 1. This can be set by using the value in the
+                // input matrix.
+                if (i == 0 || j == 0) {
+                    currRow[j] = matrix[i][j];
+                } else {
+                    if (matrix[i][j] == 1) {
+                        // currRow[j] = 1 + min(left, top-left, top)
+                        currRow[j] = 1 + Math.min(currRow[j - 1], Math.min(prevRow[j - 1], prevRow[j]));
+                    }
+                }
+                maxLen = Math.max(maxLen, currRow[j]);
+            }
+            // Update 'prevRow' with 'currRow' values for the next iteration.
+            prevRow = currRow;
+        }
+        return maxLen * maxLen;
+    }
+}

java/Dynamic Programming/LongestCommonSubsequence.java

@@ -0,0 +1,26 @@
+public class LongestCommonSubsequence {
+    public int longestCommonSubsequence(String s1, String s2) {
+        // Base case: Set the last row and last column to 0 by
+        // initializing the entire DP table with 0s.
+        int[][] dp = new int[s1.length() + 1][s2.length() + 1];
+        // Populate the DP table.
+        for (int i = s1.length() - 1; i >= 0; i--) {
+            for (int j = s2.length() - 1; j >= 0; j--) {
+                // If the characters match, the length of the LCS at
+                // 'dp[i][j]' is 1 + the LCS length of the remaining
+                // substrings.
+                if (s1.charAt(i) == s2.charAt(j)) {
+                    dp[i][j] = 1 + dp[i + 1][j + 1];
+                }
+                // If the characters don't match, the LCS length at
+                // 'dp[i][j]' can be found by either:
+                // 1. Excluding the current character of s1.
+                // 2. Excluding the current character of s2.
+                else {
+                    dp[i][j] = Math.max(dp[i + 1][j], dp[i][j + 1]);
+                }
+            }
+        }
+        return dp[0][0];
+    }
+}

java/Dynamic Programming/LongestCommonSubsequenceOptimized.java

@@ -0,0 +1,30 @@
+public class LongestCommonSubsequenceOptimized {
+    public int longestCommonSubsequenceOptimized(String s1, String s2) {
+        // Initialize 'prevRow' as the DP values of the last row.
+        int[] prevRow = new int[s2.length() + 1];
+        for (int i = s1.length() - 1; i >= 0; i--) {
+            // Set the last cell of 'currRow' to 0 to set the base case for
+            // this row. This is done by initializing the entire row to 0.
+            int[] currRow = new int[s2.length() + 1];
+            for (int j = s2.length() - 1; j >= 0; j--) {
+                // If the characters match, the length of the LCS at
+                // 'currRow[j]' is 1 + the LCS length of the remaining
+                // substrings ('prevRow[j + 1]').
+                if (s1.charAt(i) == s2.charAt(j)) {
+                    currRow[j] = 1 + prevRow[j + 1];
+                }
+                // If the characters don't match, the LCS length at
+                // 'currRow[j]' can be found by either:
+                // 1. Excluding the current character of s1 ('prevRow[j]').
+                // 2. Excluding the current character of s2 ('currRow[j + 1]').
+                else {
+                    currRow[j] = Math.max(prevRow[j], currRow[j + 1]);
+                }
+            }
+            // Update 'prevRow' with 'currRow' values for the next
+            // iteration.
+            prevRow = currRow;
+        }
+        return prevRow[0];
+    }
+}

java/Dynamic Programming/LongestPalindromeInAString.java

@@ -0,0 +1,40 @@
+public class LongestPalindromeInAString {
+    public String longestPalindromeInAString(String s) {
+        int n = s.length();
+        if (n == 0) {
+            return "";
+        }
+        boolean[][] dp = new boolean[n][n];
+        int maxLen = 1;
+        int startIndex = 0;
+        // Base case: a single character is always a palindrome.
+        for (int i = 0; i < n; i++) {
+            dp[i][i] = true;
+        }
+        // Base case: a substring of length two is a palindrome if both
+        // characters are the same.
+        for (int i = 0; i < n - 1; i++) {
+            if (s.charAt(i) == s.charAt(i + 1)) {
+                dp[i][i + 1] = true;
+                maxLen = 2;
+                startIndex = i;
+            }
+        }
+        // Find palindromic substrings of length 3 or greater.
+        for (int substringLen = 3; substringLen < n + 1; substringLen++) {
+            // Iterate through each substring of length 'substringLen'.
+            for (int i = 0; i < n - substringLen + 1; i++) {
+                int j = i + substringLen - 1;
+                // If the first and last characters are the same, and the
+                // inner substring is a palindrome, then the current
+                // substring is a palindrome.
+                if (s.charAt(i) == s.charAt(j) && dp[i + 1][j - 1]) {
+                    dp[i][j] = true;
+                    maxLen = substringLen;
+                    startIndex = i;
+                }
+            }
+        }
+        return s.substring(startIndex, startIndex + maxLen);
+    }
+}

java/Dynamic Programming/LongestPalindromeInAStringExpanding.java

@@ -0,0 +1,41 @@
+public class LongestPalindromeInAStringExpanding {
+    public String longestPalindromeInAStringExpanding(String s) {
+        int n = s.length();
+        int start, maxLen;
+        start = maxLen = 0;
+        for (int center = 0; center < n; center++) {
+            // Check for odd-length palindromes.
+            int oddStart, oddLength;
+            int[] oddResult = expandPalindrome(center, center, s);
+            oddStart = oddResult[0];
+            oddLength = oddResult[1];
+            if (oddLength > maxLen) {
+                start = oddStart;
+                maxLen = oddLength;
+            }
+            // Check for even-length palindromes.
+            if (center < n - 1 && s.charAt(center) == s.charAt(center + 1)) {
+                int evenStart, evenLength;
+                int[] evenResult = expandPalindrome(center, center + 1, s);
+                evenStart = evenResult[0];
+                evenLength = evenResult[1];
+                if (evenLength > maxLen) {
+                    start = evenStart;
+                    maxLen = evenLength;
+                }
+            }
+        }
+        return s.substring(start, start + maxLen);
+    }
+
+    // Expands outward from the center of a base case to identify the start 
+    // index and length of the longest palindrome that extends from this 
+    // base case.
+    private int[] expandPalindrome(int left, int right, String s) {
+        while (left > 0 && right < s.length() - 1 && s.charAt(left - 1) == s.charAt(right + 1)) {
+            left--;
+            right++;
+        }
+        return new int[]{left, right - left + 1};
+    }
+}

java/Dynamic Programming/MatrixPathways.java

@@ -0,0 +1,21 @@
+import java.util.Arrays;
+
+public class MatrixPathways {
+    public int matrixPathways(int m, int n) {
+        // Base cases: Set all cells in row 0 and column 0 to 1. We can
+        // do this by initializing all cells in the DP table to 1.
+        int[][] dp = new int[m][n];
+        for (int i = 0; i < m; i++) {
+            Arrays.fill(dp[i], 1);
+        }
+        // Fill in the rest of the DP table.
+        for (int r = 1; r < m; r++) {
+            for (int c = 1; c < n; c++) {
+                // Paths to current cell = paths from above + paths from 
+                // left.
+                dp[r][c] = dp[r - 1][c] + dp[r][c - 1];
+            }
+        }
+        return dp[m - 1][n - 1];
+    }
+}

java/Dynamic Programming/MatrixPathwaysOptimized.java

@@ -0,0 +1,28 @@
+import java.util.Arrays;
+
+public class MatrixPathwaysOptimized {
+    public int matrixPathwaysOptimized(int m, int n) {
+        // Initialize 'prevRow' as the DP values of row 0, which are all 1s.
+        int[] prevRow = new int[n];
+        Arrays.fill(prevRow, 1);
+        // Iterate through the matrix starting from row 1.
+        for (int r = 1; r < m; r++) {
+            // Set the first cell of 'curr_row' to 1. This is done by
+            // setting the entire row to 1.
+            int[] currRow = new int[n];
+            Arrays.fill(currRow, 1);
+            for (int c = 1; c < n; c++) {
+                // The number of unique paths to the current cell is the sum
+                // of the paths from the cell above it ('prevRow[c]') and
+                // the cell to the left ('currRow[c - 1]').
+                currRow[c] = prevRow[c] + currRow[c - 1];
+            }
+            // Update 'prevRow' with 'currRow' values for the next
+            // iteration.
+            prevRow = currRow;
+        }
+        // The last element in 'prevRow' stores the result for the
+        // bottom-right cell.
+        return prevRow[n - 1];
+    }
+}