feat: add Valid Parenthesis String problem

- Greedy algorithm implementation
- Multiple approaches: DP, Backtracking, Iterative, While loop
- O(n) time, O(1) space complexity
- Comprehensive explanations and edge cases

Author: TechnoBlogger14o3

neetcode-150/greedy/valid-parenthesis-string/explanation.md

@@ -0,0 +1,87 @@
+# Valid Parenthesis String
+
+## Problem Statement
+
+Given a string `s` containing only three types of characters: `'('`, `')'` and `'*'`, return `true` if `s` is valid.
+
+The following rules define a valid string:
+
+- Any left parenthesis `'('` must have a corresponding right parenthesis `')'`.
+- Any right parenthesis `')'` must have a corresponding left parenthesis `'('`.
+- Left parenthesis `'('` must go before the corresponding right parenthesis `')'`.
+- `'*'` could be treated as a single right parenthesis `')'`, a single left parenthesis `'('`, or an empty string.
+
+## Examples
+
+**Example 1:**
+```
+Input: s = "()"
+Output: true
+```
+
+## Approach
+
+### Method 1: Greedy Algorithm (Recommended)
+1. Track minimum and maximum possible open parentheses
+2. Use greedy approach to handle wildcards
+3. If min becomes negative, reset to 0
+4. Most efficient approach
+
+**Time Complexity:** O(n) - Single pass
+**Space Complexity:** O(1) - Two variables
+
+### Method 2: Dynamic Programming
+1. Use DP to track all possible states
+2. Less efficient than greedy approach
+3. More complex implementation
+
+**Time Complexity:** O(n) - Single pass
+**Space Complexity:** O(n) - DP array
+
+## Algorithm
+
+```
+1. Initialize minOpen = 0, maxOpen = 0
+2. For each character in s:
+   a. If '(': minOpen++, maxOpen++
+   b. If ')': minOpen--, maxOpen--
+   c. If '*': minOpen--, maxOpen++
+   d. If maxOpen < 0: return false
+   e. If minOpen < 0: minOpen = 0
+3. Return minOpen == 0
+```
+
+## Key Insights
+
+- **Greedy Choice**: Handle wildcards optimally
+- **Local Optimum**: Track possible open parentheses
+- **Global Optimum**: Can form valid parentheses
+- **Space Optimization**: Use only two variables
+
+## Alternative Approaches
+
+1. **Dynamic Programming**: Use DP array
+2. **Backtracking**: Use backtracking to explore all possibilities
+3. **Stack**: Use stack to track parentheses
+
+## Edge Cases
+
+- Empty string: Return true
+- Single character: Handle appropriately
+- All wildcards: Return true
+- No wildcards: Use standard parentheses validation
+
+## Applications
+
+- Greedy algorithms
+- String validation
+- Algorithm design patterns
+- Interview preparation
+- System design
+
+## Optimization Opportunities
+
+- **Greedy Algorithm**: Most efficient approach
+- **Space Optimization**: O(1) space complexity
+- **Single Pass**: O(n) time complexity
+- **No Extra Space**: Use only two variables

neetcode-150/greedy/valid-parenthesis-string/solution.java

@@ -0,0 +1,221 @@
+/**
+ * Time Complexity: O(n) - Single pass
+ * Space Complexity: O(1) - Two variables
+ */
+class Solution {
+    public boolean checkValidString(String s) {
+        int minOpen = 0;
+        int maxOpen = 0;
+        
+        for (char c : s.toCharArray()) {
+            if (c == '(') {
+                minOpen++;
+                maxOpen++;
+            } else if (c == ')') {
+                minOpen--;
+                maxOpen--;
+            } else { // c == '*'
+                minOpen--;
+                maxOpen++;
+            }
+            
+            if (maxOpen < 0) {
+                return false;
+            }
+            
+            if (minOpen < 0) {
+                minOpen = 0;
+            }
+        }
+        
+        return minOpen == 0;
+    }
+}
+
+// Alternative approach using Dynamic Programming
+class SolutionDP {
+    public boolean checkValidString(String s) {
+        int n = s.length();
+        boolean[][] dp = new boolean[n + 1][n + 1];
+        dp[0][0] = true;
+        
+        for (int i = 1; i <= n; i++) {
+            char c = s.charAt(i - 1);
+            
+            for (int j = 0; j <= n; j++) {
+                if (c == '(') {
+                    if (j > 0) {
+                        dp[i][j] = dp[i - 1][j - 1];
+                    }
+                } else if (c == ')') {
+                    if (j < n) {
+                        dp[i][j] = dp[i - 1][j + 1];
+                    }
+                } else { // c == '*'
+                    dp[i][j] = dp[i - 1][j];
+                    if (j > 0) {
+                        dp[i][j] = dp[i][j] || dp[i - 1][j - 1];
+                    }
+                    if (j < n) {
+                        dp[i][j] = dp[i][j] || dp[i - 1][j + 1];
+                    }
+                }
+            }
+        }
+        
+        return dp[n][0];
+    }
+}
+
+// Alternative approach using backtracking
+class SolutionBacktracking {
+    public boolean checkValidString(String s) {
+        return checkValidStringHelper(s, 0, 0);
+    }
+    
+    private boolean checkValidStringHelper(String s, int index, int openCount) {
+        if (index == s.length()) {
+            return openCount == 0;
+        }
+        
+        char c = s.charAt(index);
+        
+        if (c == '(') {
+            return checkValidStringHelper(s, index + 1, openCount + 1);
+        } else if (c == ')') {
+            if (openCount <= 0) {
+                return false;
+            }
+            return checkValidStringHelper(s, index + 1, openCount - 1);
+        } else { // c == '*'
+            // Try all three possibilities: '(', ')', or empty
+            return checkValidStringHelper(s, index + 1, openCount + 1) ||
+                   checkValidStringHelper(s, index + 1, openCount - 1) ||
+                   checkValidStringHelper(s, index + 1, openCount);
+        }
+    }
+}
+
+// Alternative approach using iterative
+class SolutionIterative {
+    public boolean checkValidString(String s) {
+        int minOpen = 0;
+        int maxOpen = 0;
+        
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            
+            if (c == '(') {
+                minOpen++;
+                maxOpen++;
+            } else if (c == ')') {
+                minOpen--;
+                maxOpen--;
+            } else { // c == '*'
+                minOpen--;
+                maxOpen++;
+            }
+            
+            if (maxOpen < 0) {
+                return false;
+            }
+            
+            if (minOpen < 0) {
+                minOpen = 0;
+            }
+        }
+        
+        return minOpen == 0;
+    }
+}
+
+// Alternative approach using while loop
+class SolutionWhileLoop {
+    public boolean checkValidString(String s) {
+        int minOpen = 0;
+        int maxOpen = 0;
+        int i = 0;
+        
+        while (i < s.length()) {
+            char c = s.charAt(i);
+            
+            if (c == '(') {
+                minOpen++;
+                maxOpen++;
+            } else if (c == ')') {
+                minOpen--;
+                maxOpen--;
+            } else { // c == '*'
+                minOpen--;
+                maxOpen++;
+            }
+            
+            if (maxOpen < 0) {
+                return false;
+            }
+            
+            if (minOpen < 0) {
+                minOpen = 0;
+            }
+            
+            i++;
+        }
+        
+        return minOpen == 0;
+    }
+}
+
+// Alternative approach using enhanced for loop
+class SolutionEnhancedForLoop {
+    public boolean checkValidString(String s) {
+        int minOpen = 0;
+        int maxOpen = 0;
+        
+        for (char c : s.toCharArray()) {
+            if (c == '(') {
+                minOpen++;
+                maxOpen++;
+            } else if (c == ')') {
+                minOpen--;
+                maxOpen--;
+            } else { // c == '*'
+                minOpen--;
+                maxOpen++;
+            }
+            
+            if (maxOpen < 0) {
+                return false;
+            }
+            
+            if (minOpen < 0) {
+                minOpen = 0;
+            }
+        }
+        
+        return minOpen == 0;
+    }
+}
+
+// More concise version
+class SolutionConcise {
+    public boolean checkValidString(String s) {
+        int minOpen = 0, maxOpen = 0;
+        for (char c : s.toCharArray()) {
+            if (c == '(') {
+                minOpen++;
+                maxOpen++;
+            } else if (c == ')') {
+                minOpen--;
+                maxOpen--;
+            } else { // c == '*'
+                minOpen--;
+                maxOpen++;
+            }
+            
+            if (maxOpen < 0) return false;
+            if (minOpen < 0) minOpen = 0;
+        }
+        
+        return minOpen == 0;
+    }
+}