feat: add solutions to lc problem: No.0678

No.0678.Valid Parenthesis String

Author: yanglbme

README_EN.md

@@ -196,7 +196,7 @@ You can also contribute to [doocs/leetcode](https://github.com/doocs/leetcode) u
 
 <a href="https://github.com/doocs/leetcode/stargazers" target="_blank"><img src="./images/starcharts.svg" alt="Stargazers over time" /></a>
 
-## Contributors
+## Our Top Contributors
 
 This project exists thanks to all the people who contribute.
 

solution/0600-0699/0678.Valid Parenthesis String/README.md

@@ -47,7 +47,24 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-两遍扫描，第一遍从左往右，确定每一个右括号都可以成功配对，第二遍从右往左，确定每一个左括号都可以成功配对
+**方法一：动态规划**
+
+定义 $dp[i][j]$ 表示字符串 $s$ 中下标范围 $[i..j]$ 内的子串是否为有效括号字符串。答案为 $dp[0][n - 1]$。
+
+子串长度为 $1$ 时，如果字符 $s[i]$ 为 `*`，则 $dp[i][i]$ 为 `true`，否则为 `false`。
+
+子串长度大于 $1$ 时，如果满足下面任意一种情况，则 $dp[i][j]$ 为 `true`：
+
+-   子串 $s[i..j]$ 的左边界为 `(` 或 `*`，且右边界为 `*` 或 `)`，且 $s[i+1..j-1]$ 为有效括号字符串；
+-   子串 $s[i..j]$ 中的任意下标 $k$，如果 $s[i..k]$ 为有效括号字符串，且 $s[k+1..j]$ 为有效括号字符串，则 $s[i..j]$ 为有效括号字符串。
+
+时间复杂度 $O(n^3)$，空间复杂度 $O(n^2)$。其中 $n$ 为字符串 `s` 的长度。
+
+**方法二：贪心 + 两遍扫描**
+
+两遍扫描，第一遍从左往右，确定每一个右括号都可以成功配对，第二遍从右往左，确定每一个左括号都可以成功配对。
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为字符串 `s` 的长度。
 
 <!-- tabs:start -->
 
@@ -59,7 +76,25 @@
 class Solution:
     def checkValidString(self, s: str) -> bool:
         n = len(s)
-        left, asterisk = 0, 0
+        dp = [[False] * n for _ in range(n)]
+        for i, c in enumerate(s):
+            dp[i][i] = c == '*'
+        for i in range(n - 2, -1, -1):
+            for j in range(i + 1, n):
+                dp[i][j] = (
+                    s[i] in '(*' and s[j] in '*)' and (i + 1 == j or dp[i + 1][j - 1])
+                )
+                dp[i][j] = dp[i][j] or any(
+                    dp[i][k] and dp[k + 1][j] for k in range(i, j)
+                )
+        return dp[0][-1]
+```
+
+```python
+class Solution:
+    def checkValidString(self, s: str) -> bool:
+        n = len(s)
+        left = asterisk = 0
         for i in range(n):
             if s[i] == "(":
                 left += 1
@@ -72,7 +107,7 @@ class Solution:
                     return False
             else:
                 asterisk += 1
-        right, asterisk = 0, 0
+        right = asterisk = 0
         for i in range(n - 1, -1, -1):
             if s[i] == ")":
                 right += 1
@@ -92,6 +127,28 @@ class Solution:
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```java
+class Solution {
+    public boolean checkValidString(String s) {
+        int n = s.length();
+        boolean[][] dp = new boolean[n][n];
+        for (int i = 0; i < n; ++i) {
+            dp[i][i] = s.charAt(i) == '*';
+        }
+        for (int i = n - 2; i >= 0; --i) {
+            for (int j = i + 1; j < n; ++j) {
+                char a = s.charAt(i), b = s.charAt(j);
+                dp[i][j] = (a == '(' || a == '*') && (b == '*' || b == ')') && (i + 1 == j || dp[i + 1][j - 1]);
+                for (int k = i; k < j && !dp[i][j]; ++k) {
+                    dp[i][j] = dp[i][k] && dp[k + 1][j];
+                }
+            }
+        }
+        return dp[0][n - 1];
+    }
+}
+```
+
 ```java
 class Solution {
     public boolean checkValidString(String s) {
@@ -137,6 +194,29 @@ class Solution {
 
 ### **C++**
 
+```cpp
+class Solution {
+public:
+    bool checkValidString(string s) {
+        int n = s.size();
+        vector<vector<bool>> dp(n, vector<bool>(n));
+        for (int i = 0; i < n; ++i) {
+            dp[i][i] = s[i] == '*';
+        }
+        for (int i = n - 2; i >= 0; --i) {
+            for (int j = i + 1; j < n; ++j) {
+                char a = s[i], b = s[j];
+                dp[i][j] = (a == '(' || a == '*') && (b == '*' || b == ')') && (i + 1 == j || dp[i + 1][j - 1]);
+                for (int k = i; k < j && !dp[i][j]; ++k) {
+                    dp[i][j] = dp[i][k] && dp[k + 1][j];
+                }
+            }
+        }
+        return dp[0][n - 1];
+    }
+};
+```
+
 ```cpp
 class Solution {
 public:
@@ -180,6 +260,27 @@ public:
 
 ### **Go**
 
+```go
+func checkValidString(s string) bool {
+	n := len(s)
+	dp := make([][]bool, n)
+	for i := range dp {
+		dp[i] = make([]bool, n)
+		dp[i][i] = s[i] == '*'
+	}
+	for i := n - 2; i >= 0; i-- {
+		for j := i + 1; j < n; j++ {
+			a, b := s[i], s[j]
+			dp[i][j] = (a == '(' || a == '*') && (b == '*' || b == ')') && (i+1 == j || dp[i+1][j-1])
+			for k := i; k < j && !dp[i][j]; k++ {
+				dp[i][j] = dp[i][k] && dp[k+1][j]
+			}
+		}
+	}
+	return dp[0][n-1]
+}
+```
+
 ```go
 func checkValidString(s string) bool {
 	n := len(s)

solution/0600-0699/0678.Valid Parenthesis String/README_EN.md

@@ -36,7 +36,22 @@
 
 ## Solutions
 
-Scan twice, first from left to right to make sure that each of the closing brackets is matched successfully, and second from right to left to make sure that each of the opening brackets is matched successfully
+**Approach 1: Dynamic Programming**
+
+Let `dp[i][j]` be true if and only if the interval `s[i], s[i+1], ..., s[j]` can be made valid. Then `dp[i][j]` is true only if:
+
+-   `s[i]` is `'*'`, and the interval `s[i+1], s[i+2], ..., s[j]` can be made valid;
+-   or, `s[i]` can be made to be `'('`, and there is some `k` in `[i+1, j]` such that `s[k]` can be made to be `')'`, plus the two intervals cut by `s[k]` (`s[i+1: k] and s[k+1: j+1]`) can be made valid;
+
+-   Time Complexity: $O(n^3)$, where $n$ is the length of the string. There are $O(n^2)$ states corresponding to entries of dp, and we do an average of $O(n)$ work on each state.
+-   Space Complexity: $O(n^2)$.
+
+**Approach 2: Greedy**
+
+Scan twice, first from left to right to make sure that each of the closing brackets is matched successfully, and second from right to left to make sure that each of the opening brackets is matched successfully.
+
+-   Time Complexity: $O(n)$, where $n$ is the length of the string.
+-   Space Complexity: $O(1)$.
 
 <!-- tabs:start -->
 
@@ -46,7 +61,25 @@ Scan twice, first from left to right to make sure that each of the closing brack
 class Solution:
     def checkValidString(self, s: str) -> bool:
         n = len(s)
-        left, asterisk = 0, 0
+        dp = [[False] * n for _ in range(n)]
+        for i, c in enumerate(s):
+            dp[i][i] = c == '*'
+        for i in range(n - 2, -1, -1):
+            for j in range(i + 1, n):
+                dp[i][j] = (
+                    s[i] in '(*' and s[j] in '*)' and (i + 1 == j or dp[i + 1][j - 1])
+                )
+                dp[i][j] = dp[i][j] or any(
+                    dp[i][k] and dp[k + 1][j] for k in range(i, j)
+                )
+        return dp[0][-1]
+```
+
+```python
+class Solution:
+    def checkValidString(self, s: str) -> bool:
+        n = len(s)
+        left = asterisk = 0
         for i in range(n):
             if s[i] == "(":
                 left += 1
@@ -59,7 +92,7 @@ class Solution:
                     return False
             else:
                 asterisk += 1
-        right, asterisk = 0, 0
+        right = asterisk = 0
         for i in range(n - 1, -1, -1):
             if s[i] == ")":
                 right += 1
@@ -77,6 +110,28 @@ class Solution:
 
 ### **Java**
 
+```java
+class Solution {
+    public boolean checkValidString(String s) {
+        int n = s.length();
+        boolean[][] dp = new boolean[n][n];
+        for (int i = 0; i < n; ++i) {
+            dp[i][i] = s.charAt(i) == '*';
+        }
+        for (int i = n - 2; i >= 0; --i) {
+            for (int j = i + 1; j < n; ++j) {
+                char a = s.charAt(i), b = s.charAt(j);
+                dp[i][j] = (a == '(' || a == '*') && (b == '*' || b == ')') && (i + 1 == j || dp[i + 1][j - 1]);
+                for (int k = i; k < j && !dp[i][j]; ++k) {
+                    dp[i][j] = dp[i][k] && dp[k + 1][j];
+                }
+            }
+        }
+        return dp[0][n - 1];
+    }
+}
+```
+
 ```java
 class Solution {
     public boolean checkValidString(String s) {
@@ -122,6 +177,29 @@ class Solution {
 
 ### **C++**
 
+```cpp
+class Solution {
+public:
+    bool checkValidString(string s) {
+        int n = s.size();
+        vector<vector<bool>> dp(n, vector<bool>(n));
+        for (int i = 0; i < n; ++i) {
+            dp[i][i] = s[i] == '*';
+        }
+        for (int i = n - 2; i >= 0; --i) {
+            for (int j = i + 1; j < n; ++j) {
+                char a = s[i], b = s[j];
+                dp[i][j] = (a == '(' || a == '*') && (b == '*' || b == ')') && (i + 1 == j || dp[i + 1][j - 1]);
+                for (int k = i; k < j && !dp[i][j]; ++k) {
+                    dp[i][j] = dp[i][k] && dp[k + 1][j];
+                }
+            }
+        }
+        return dp[0][n - 1];
+    }
+};
+```
+
 ```cpp
 class Solution {
 public:
@@ -165,6 +243,27 @@ public:
 
 ### **Go**
 
+```go
+func checkValidString(s string) bool {
+	n := len(s)
+	dp := make([][]bool, n)
+	for i := range dp {
+		dp[i] = make([]bool, n)
+		dp[i][i] = s[i] == '*'
+	}
+	for i := n - 2; i >= 0; i-- {
+		for j := i + 1; j < n; j++ {
+			a, b := s[i], s[j]
+			dp[i][j] = (a == '(' || a == '*') && (b == '*' || b == ')') && (i+1 == j || dp[i+1][j-1])
+			for k := i; k < j && !dp[i][j]; k++ {
+				dp[i][j] = dp[i][k] && dp[k+1][j]
+			}
+		}
+	}
+	return dp[0][n-1]
+}
+```
+
 ```go
 func checkValidString(s string) bool {
 	n := len(s)

solution/0600-0699/0678.Valid Parenthesis String/Solution.py

@@ -1,7 +1,7 @@
 class Solution:
     def checkValidString(self, s: str) -> bool:
         n = len(s)
-        left, asterisk = 0, 0
+        left = asterisk = 0
         for i in range(n):
             if s[i] == "(":
                 left += 1
@@ -14,7 +14,7 @@ def checkValidString(self, s: str) -> bool:
                     return False
             else:
                 asterisk += 1
-        right, asterisk = 0, 0
+        right = asterisk = 0
         for i in range(n - 1, -1, -1):
             if s[i] == ")":
                 right += 1