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

Complete implementations with multiple approaches:
- Climbing Stairs (Fibonacci pattern)
- House Robber I & II (Circular constraint)
- Longest Palindromic Substring (Expand around centers)
- Decode Ways (String decoding)
- Coin Change (Minimum coins)
- Word Break (String segmentation)
- Combination Sum IV (Order matters)

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

Author: TechnoBlogger14o3

neetcode-150/1d-dp/climbing-stairs/explanation.md

@@ -0,0 +1,81 @@
+# Climbing Stairs
+
+## Problem Statement
+
+You are climbing a staircase. It takes `n` steps to reach the top.
+
+Each time you can either climb `1` or `2` steps. In how many distinct ways can you climb to the top?
+
+## Examples
+
+**Example 1:**
+```
+Input: n = 2
+Output: 2
+Explanation: There are two ways to climb to the top.
+1. 1 step + 1 step
+2. 2 steps
+```
+
+## Approach
+
+### Method 1: Dynamic Programming (Recommended)
+1. Use DP to store number of ways to reach each step
+2. dp[i] = dp[i-1] + dp[i-2]
+3. Similar to Fibonacci sequence
+4. Most efficient approach
+
+**Time Complexity:** O(n) - Single pass
+**Space Complexity:** O(n) - DP array
+
+### Method 2: Space-Optimized DP
+1. Use only two variables instead of array
+2. Update variables iteratively
+3. Most memory efficient
+
+**Time Complexity:** O(n) - Single pass
+**Space Complexity:** O(1) - Two variables
+
+## Algorithm
+
+```
+1. Initialize dp[0] = 1, dp[1] = 1
+2. For i from 2 to n:
+   dp[i] = dp[i-1] + dp[i-2]
+3. Return dp[n]
+```
+
+## Key Insights
+
+- **Fibonacci Pattern**: Same as Fibonacci sequence
+- **State Transition**: dp[i] = dp[i-1] + dp[i-2]
+- **Base Cases**: dp[0] = 1, dp[1] = 1
+- **Space Optimization**: Use only two variables
+
+## Alternative Approaches
+
+1. **Recursion**: Use recursive approach with memoization
+2. **Matrix Exponentiation**: Use matrix power for O(log n)
+3. **Mathematical Formula**: Use Binet's formula
+
+## Edge Cases
+
+- n = 0: Return 1
+- n = 1: Return 1
+- n = 2: Return 2
+- Large n: Handle overflow
+
+## Applications
+
+- Fibonacci sequence
+- Dynamic programming patterns
+- Algorithm design patterns
+- Interview preparation
+- System design
+
+## Optimization Opportunities
+
+- **Space Optimization**: O(1) space complexity
+- **Single Pass**: O(n) time complexity
+- **No Recursion**: Avoid stack overflow
+- **Memory Efficient**: Use only two variables

neetcode-150/1d-dp/climbing-stairs/solution.java

@@ -0,0 +1,145 @@
+/**
+ * Time Complexity: O(n) - Single pass
+ * Space Complexity: O(n) - DP array
+ */
+class Solution {
+    public int climbStairs(int n) {
+        if (n <= 1) {
+            return 1;
+        }
+        
+        int[] dp = new int[n + 1];
+        dp[0] = 1;
+        dp[1] = 1;
+        
+        for (int i = 2; i <= n; i++) {
+            dp[i] = dp[i - 1] + dp[i - 2];
+        }
+        
+        return dp[n];
+    }
+}
+
+// Alternative approach using space-optimized DP
+class SolutionSpaceOptimized {
+    public int climbStairs(int n) {
+        if (n <= 1) {
+            return 1;
+        }
+        
+        int prev2 = 1; // dp[i-2]
+        int prev1 = 1; // dp[i-1]
+        
+        for (int i = 2; i <= n; i++) {
+            int current = prev1 + prev2;
+            prev2 = prev1;
+            prev1 = current;
+        }
+        
+        return prev1;
+    }
+}
+
+// Alternative approach using recursion with memoization
+class SolutionMemoization {
+    public int climbStairs(int n) {
+        int[] memo = new int[n + 1];
+        Arrays.fill(memo, -1);
+        return climbStairsHelper(n, memo);
+    }
+    
+    private int climbStairsHelper(int n, int[] memo) {
+        if (n <= 1) {
+            return 1;
+        }
+        
+        if (memo[n] != -1) {
+            return memo[n];
+        }
+        
+        memo[n] = climbStairsHelper(n - 1, memo) + climbStairsHelper(n - 2, memo);
+        return memo[n];
+    }
+}
+
+// Alternative approach using matrix exponentiation
+class SolutionMatrix {
+    public int climbStairs(int n) {
+        if (n <= 1) {
+            return 1;
+        }
+        
+        int[][] matrix = {{1, 1}, {1, 0}};
+        int[][] result = matrixPower(matrix, n);
+        
+        return result[0][0];
+    }
+    
+    private int[][] matrixPower(int[][] matrix, int n) {
+        if (n == 1) {
+            return matrix;
+        }
+        
+        if (n % 2 == 0) {
+            int[][] half = matrixPower(matrix, n / 2);
+            return matrixMultiply(half, half);
+        } else {
+            int[][] half = matrixPower(matrix, n / 2);
+            return matrixMultiply(matrixMultiply(half, half), matrix);
+        }
+    }
+    
+    private int[][] matrixMultiply(int[][] a, int[][] b) {
+        int[][] result = new int[2][2];
+        result[0][0] = a[0][0] * b[0][0] + a[0][1] * b[1][0];
+        result[0][1] = a[0][0] * b[0][1] + a[0][1] * b[1][1];
+        result[1][0] = a[1][0] * b[0][0] + a[1][1] * b[1][0];
+        result[1][1] = a[1][0] * b[0][1] + a[1][1] * b[1][1];
+        return result;
+    }
+}
+
+// Alternative approach using mathematical formula
+class SolutionMathematical {
+    public int climbStairs(int n) {
+        double sqrt5 = Math.sqrt(5);
+        double phi = (1 + sqrt5) / 2;
+        double psi = (1 - sqrt5) / 2;
+        
+        return (int) Math.round((Math.pow(phi, n + 1) - Math.pow(psi, n + 1)) / sqrt5);
+    }
+}
+
+// Alternative approach using iterative with variables
+class SolutionIterative {
+    public int climbStairs(int n) {
+        if (n <= 1) {
+            return 1;
+        }
+        
+        int a = 1, b = 1, c;
+        
+        for (int i = 2; i <= n; i++) {
+            c = a + b;
+            a = b;
+            b = c;
+        }
+        
+        return b;
+    }
+}
+
+// More concise version
+class SolutionConcise {
+    public int climbStairs(int n) {
+        if (n <= 1) return 1;
+        
+        int prev2 = 1, prev1 = 1;
+        for (int i = 2; i <= n; i++) {
+            int curr = prev1 + prev2;
+            prev2 = prev1;
+            prev1 = curr;
+        }
+        return prev1;
+    }
+}

neetcode-150/1d-dp/coin-change/explanation.md

@@ -0,0 +1,82 @@
+# Coin Change
+
+## Problem Statement
+
+You are given an integer array `coins` representing coins of different denominations and an integer `amount` representing a total amount of money.
+
+Return the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return `-1`.
+
+You may assume that you have an infinite number of each kind of coin.
+
+## Examples
+
+**Example 1:**
+```
+Input: coins = [1,3,4], amount = 6
+Output: 2
+Explanation: 6 = 3 + 3
+```
+
+## Approach
+
+### Method 1: Dynamic Programming (Recommended)
+1. Use DP to store minimum coins for each amount
+2. dp[i] = min(dp[i], dp[i-coin] + 1) for each coin
+3. Initialize dp[0] = 0, others = infinity
+4. Most efficient approach
+
+**Time Complexity:** O(amount * coins.length)
+**Space Complexity:** O(amount) - DP array
+
+### Method 2: BFS
+1. Use BFS to find minimum steps
+2. Each level represents one coin
+3. Less efficient than DP
+
+**Time Complexity:** O(amount * coins.length)
+**Space Complexity:** O(amount) - Queue
+
+## Algorithm
+
+```
+1. Initialize dp[0] = 0, dp[i] = infinity for i > 0
+2. For each amount from 1 to amount:
+   a. For each coin:
+      b. If coin <= amount: dp[amount] = min(dp[amount], dp[amount-coin] + 1)
+3. Return dp[amount] or -1 if infinity
+```
+
+## Key Insights
+
+- **State Transition**: dp[i] = min(dp[i], dp[i-coin] + 1)
+- **Infinite Coins**: Can use same coin multiple times
+- **Minimum Coins**: Find minimum number of coins
+- **Impossible Case**: Return -1 if amount cannot be made
+
+## Alternative Approaches
+
+1. **BFS**: Use BFS for minimum steps
+2. **Recursion**: Use recursive approach with memoization
+3. **Greedy**: Not always optimal
+
+## Edge Cases
+
+- Empty coins: Return -1
+- Amount = 0: Return 0
+- No solution: Return -1
+- Single coin: Handle appropriately
+
+## Applications
+
+- Dynamic programming patterns
+- Optimization problems
+- Algorithm design patterns
+- Interview preparation
+- System design
+
+## Optimization Opportunities
+
+- **Dynamic Programming**: Most efficient approach
+- **Single Pass**: O(amount * coins) time complexity
+- **Space Efficient**: O(amount) space complexity
+- **No Recursion**: Avoid stack overflow