feat: add NeetCode 150 - 2D Dynamic Programming category (8 problems)

Complete implementations with multiple approaches:
- Unique Paths (Grid traversal)
- Longest Common Subsequence (String comparison)
- Edit Distance (String transformation)
- Interleaving String (String combination)
- Distinct Subsequences (Subsequence counting)
- Word Break II (Sentence generation)
- Palindrome Partitioning (Palindrome detection)
- Regular Expression Matching (Pattern matching)

All solutions include DP, space-optimized DP, and alternative approaches

Author: TechnoBlogger14o3

neetcode-150/2d-dp/distinct-subsequences/explanation.md

@@ -0,0 +1,87 @@
+# Distinct Subsequences
+
+## Problem Statement
+
+Given two strings `s` and `t`, return the number of distinct subsequences of `s` which equals `t`.
+
+The test cases are generated so that the answer fits in a 32-bit signed integer.
+
+## Examples
+
+**Example 1:**
+```
+Input: s = "rabbbit", t = "rabbit"
+Output: 3
+Explanation:
+As shown below, there are 3 ways you can generate "rabbit" from s.
+rabbbit
+rabbbit
+rabbbit
+```
+
+## Approach
+
+### Method 1: Dynamic Programming (Recommended)
+1. Use DP table to store number of distinct subsequences
+2. dp[i][j] = number of ways to form t[0:j] from s[0:i]
+3. Handle character matching and skipping
+4. Most efficient approach
+
+**Time Complexity:** O(m * n) - Fill DP table
+**Space Complexity:** O(m * n) - DP table
+
+### Method 2: Space-Optimized DP
+1. Use only two rows instead of full table
+2. Alternate between current and previous row
+3. Most memory efficient
+
+**Time Complexity:** O(m * n) - Fill DP table
+**Space Complexity:** O(min(m, n)) - Two rows
+
+## Algorithm
+
+```
+1. Initialize dp[0][j] = 1 for all j (empty string)
+2. For i from 1 to m:
+   For j from 1 to n:
+     If s[i-1] == t[j-1]:
+       dp[i][j] = dp[i-1][j-1] + dp[i-1][j]
+     Else:
+       dp[i][j] = dp[i-1][j]
+3. Return dp[m][n]
+```
+
+## Key Insights
+
+- **State Transition**: dp[i][j] = dp[i-1][j-1] + dp[i-1][j] if match, else dp[i-1][j]
+- **Base Case**: dp[0][j] = 1 (empty string can form empty target)
+- **Character Matching**: Check if characters match
+- **Space Optimization**: Use only two rows
+
+## Alternative Approaches
+
+1. **Recursion**: Use recursive approach with memoization
+2. **Backtracking**: Use backtracking to explore all possibilities
+3. **Iterative**: Use iterative approach
+
+## Edge Cases
+
+- Empty strings: Return 1
+- No subsequence: Return 0
+- Single character: Handle appropriately
+- Identical strings: Return 1
+
+## Applications
+
+- Dynamic programming patterns
+- String algorithms
+- Algorithm design patterns
+- Interview preparation
+- System design
+
+## Optimization Opportunities
+
+- **Space Optimization**: O(min(m, n)) space complexity
+- **Single Pass**: O(m * n) time complexity
+- **Memory Efficient**: Use only two rows
+- **No Recursion**: Avoid stack overflow

neetcode-150/2d-dp/distinct-subsequences/solution.java

@@ -0,0 +1,201 @@
+/**
+ * Time Complexity: O(m * n) - Fill DP table
+ * Space Complexity: O(m * n) - DP table
+ */
+class Solution {
+    public int numDistinct(String s, String t) {
+        int m = s.length();
+        int n = t.length();
+        int[][] dp = new int[m + 1][n + 1];
+        
+        // Initialize base case: empty string can form empty target
+        for (int i = 0; i <= m; i++) {
+            dp[i][0] = 1;
+        }
+        
+        // Fill DP table
+        for (int i = 1; i <= m; i++) {
+            for (int j = 1; j <= n; j++) {
+                if (s.charAt(i - 1) == t.charAt(j - 1)) {
+                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
+                } else {
+                    dp[i][j] = dp[i - 1][j];
+                }
+            }
+        }
+        
+        return dp[m][n];
+    }
+}
+
+// Alternative approach using space-optimized DP
+class SolutionSpaceOptimized {
+    public int numDistinct(String s, String t) {
+        int m = s.length();
+        int n = t.length();
+        
+        // Use shorter string for space optimization
+        if (m < n) {
+            return numDistinct(t, s);
+        }
+        
+        int[] prev = new int[n + 1];
+        int[] curr = new int[n + 1];
+        
+        // Initialize first row
+        prev[0] = 1;
+        
+        for (int i = 1; i <= m; i++) {
+            curr[0] = 1;
+            for (int j = 1; j <= n; j++) {
+                if (s.charAt(i - 1) == t.charAt(j - 1)) {
+                    curr[j] = prev[j - 1] + prev[j];
+                } else {
+                    curr[j] = prev[j];
+                }
+            }
+            int[] temp = prev;
+            prev = curr;
+            curr = temp;
+        }
+        
+        return prev[n];
+    }
+}
+
+// Alternative approach using recursion with memoization
+class SolutionMemoization {
+    public int numDistinct(String s, String t) {
+        int m = s.length();
+        int n = t.length();
+        int[][] memo = new int[m][n];
+        
+        for (int[] row : memo) {
+            Arrays.fill(row, -1);
+        }
+        
+        return numDistinctHelper(s, t, 0, 0, memo);
+    }
+    
+    private int numDistinctHelper(String s, String t, int i, int j, int[][] memo) {
+        if (j == t.length()) {
+            return 1;
+        }
+        
+        if (i == s.length()) {
+            return 0;
+        }
+        
+        if (memo[i][j] != -1) {
+            return memo[i][j];
+        }
+        
+        int result = 0;
+        
+        if (s.charAt(i) == t.charAt(j)) {
+            result += numDistinctHelper(s, t, i + 1, j + 1, memo);
+        }
+        
+        result += numDistinctHelper(s, t, i + 1, j, memo);
+        
+        memo[i][j] = result;
+        return result;
+    }
+}
+
+// Alternative approach using iterative
+class SolutionIterative {
+    public int numDistinct(String s, String t) {
+        int m = s.length();
+        int n = t.length();
+        int[][] dp = new int[m + 1][n + 1];
+        
+        for (int i = 0; i <= m; i++) {
+            dp[i][0] = 1;
+        }
+        
+        for (int i = 1; i <= m; i++) {
+            for (int j = 1; j <= n; j++) {
+                if (s.charAt(i - 1) == t.charAt(j - 1)) {
+                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
+                } else {
+                    dp[i][j] = dp[i - 1][j];
+                }
+            }
+        }
+        
+        return dp[m][n];
+    }
+}
+
+// Alternative approach using bottom-up DP
+class SolutionBottomUp {
+    public int numDistinct(String s, String t) {
+        int m = s.length();
+        int n = t.length();
+        int[][] dp = new int[m + 1][n + 1];
+        
+        for (int j = 0; j <= n; j++) {
+            dp[m][j] = (j == n) ? 1 : 0;
+        }
+        
+        for (int i = m - 1; i >= 0; i--) {
+            for (int j = n - 1; j >= 0; j--) {
+                if (s.charAt(i) == t.charAt(j)) {
+                    dp[i][j] = dp[i + 1][j + 1] + dp[i + 1][j];
+                } else {
+                    dp[i][j] = dp[i + 1][j];
+                }
+            }
+        }
+        
+        return dp[0][0];
+    }
+}
+
+// Alternative approach using recursion
+class SolutionRecursion {
+    public int numDistinct(String s, String t) {
+        return numDistinctHelper(s, t, 0, 0);
+    }
+    
+    private int numDistinctHelper(String s, String t, int i, int j) {
+        if (j == t.length()) {
+            return 1;
+        }
+        
+        if (i == s.length()) {
+            return 0;
+        }
+        
+        int result = 0;
+        
+        if (s.charAt(i) == t.charAt(j)) {
+            result += numDistinctHelper(s, t, i + 1, j + 1);
+        }
+        
+        result += numDistinctHelper(s, t, i + 1, j);
+        
+        return result;
+    }
+}
+
+// More concise version
+class SolutionConcise {
+    public int numDistinct(String s, String t) {
+        int m = s.length(), n = t.length();
+        int[][] dp = new int[m + 1][n + 1];
+        
+        for (int i = 0; i <= m; i++) dp[i][0] = 1;
+        
+        for (int i = 1; i <= m; i++) {
+            for (int j = 1; j <= n; j++) {
+                dp[i][j] = s.charAt(i - 1) == t.charAt(j - 1) 
+                    ? dp[i - 1][j - 1] + dp[i - 1][j] 
+                    : dp[i - 1][j];
+            }
+        }
+        
+        return dp[m][n];
+    }
+}

neetcode-150/2d-dp/edit-distance/explanation.md

@@ -0,0 +1,89 @@
+# Edit Distance
+
+## Problem Statement
+
+Given two strings `word1` and `word2`, return the minimum number of operations required to convert `word1` to `word2`.
+
+You have the following three operations permitted on a word:
+- Insert a character
+- Delete a character
+- Replace a character
+
+## Examples
+
+**Example 1:**
+```
+Input: word1 = "horse", word2 = "ros"
+Output: 3
+Explanation: 
+horse -> rorse (replace 'h' with 'r')
+rorse -> rose (remove 'r')
+rose -> ros (remove 'e')
+```
+
+## Approach
+
+### Method 1: Dynamic Programming (Recommended)
+1. Use DP table to store minimum operations
+2. dp[i][j] = min operations to convert word1[0:i] to word2[0:j]
+3. Handle insert, delete, replace operations
+4. Most efficient approach
+
+**Time Complexity:** O(m * n) - Fill DP table
+**Space Complexity:** O(m * n) - DP table
+
+### Method 2: Space-Optimized DP
+1. Use only two rows instead of full table
+2. Alternate between current and previous row
+3. Most memory efficient
+
+**Time Complexity:** O(m * n) - Fill DP table
+**Space Complexity:** O(min(m, n)) - Two rows
+
+## Algorithm
+
+```
+1. Initialize dp[0][j] = j and dp[i][0] = i
+2. For i from 1 to m:
+   For j from 1 to n:
+     If word1[i-1] == word2[j-1]:
+       dp[i][j] = dp[i-1][j-1]
+     Else:
+       dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
+3. Return dp[m][n]
+```
+
+## Key Insights
+
+- **State Transition**: dp[i][j] = min operations to convert word1[0:i] to word2[0:j]
+- **Base Cases**: dp[0][j] = j, dp[i][0] = i
+- **Three Operations**: Insert, delete, replace
+- **Space Optimization**: Use only two rows
+
+## Alternative Approaches
+
+1. **Recursion**: Use recursive approach with memoization
+2. **Backtracking**: Use backtracking to find actual operations
+3. **Iterative**: Use iterative approach
+
+## Edge Cases
+
+- Empty strings: Return length of non-empty string
+- Identical strings: Return 0
+- Single character: Handle appropriately
+- No common characters: Return max length
+
+## Applications
+
+- Dynamic programming patterns
+- String algorithms
+- Algorithm design patterns
+- Interview preparation
+- System design
+
+## Optimization Opportunities
+
+- **Space Optimization**: O(min(m, n)) space complexity
+- **Single Pass**: O(m * n) time complexity
+- **Memory Efficient**: Use only two rows
+- **No Recursion**: Avoid stack overflow