【Lintcode】1089. Valid Parenthesis String

题目地址：

https://www.lintcode.com/problem/valid-parenthesis-string/description

给定一个括号序列$s$，里面除了左右括号之外，还含'*'。'*'可以被当做左右括号，或者空串。问是否存在一种对'*'的替换，使得该序列合法。只需返回true还是false。

贪心法参考https://blog.csdn.net/qq_46105170/article/details/109269287。下面介绍动态规划做法。

法1：动态规划。设$f[i][j]$表示$s[i:j]$是否是合法的。那么当区间长度$j-i+1=1$时，$f[i][j]$为true当且仅当$s[i]=\ast$；如果区间长度是$2$，那么$f[i][j]$为true当且仅当$s[i]\ne )\wedge s[j]\ne ($；如果区间长度大于$2$，我们可以分为两种情况，第一种是$s[i]$和$s[j]$可以匹配，然后$s[i+1:j-1]$合法，第二种是存在一个$k$，使得$s[i:k]$与$s[k+1:j]$都合法。所以 f [ i ] [ j ] = { s [ i ] ≠ ) ∧ s [ j ] ≠ ( ∧ f [ i + 1 ] [ j − 1 ] } ∨ { ⋁ i < k < j f [ i ] [ k ] ∧ f [ k + 1 ] [ j ] } f[i][j]=\{s[i]\ne ) \land s[j]\ne (\land f[i+1][j-1]\}\lor \{ \bigvee_{i<k<j}f[i][k]\land f[k+1][j]\} f[i][j]={s[i]​=)∧s[j]​=(∧f[i+1][j−1]}∨{i<k<j⋁​f[i][k]∧f[k+1][j]}代码如下：

public class Solution {
    /**
     * @param s: the given string
     * @return: whether this string is valid
     */
    public boolean checkValidString(String s) {
        // Write your code here
        boolean[][] dp = new boolean[s.length()][s.length()];
        
        // 枚举区间长度
        for (int len = 1; len <= s.length(); len++) {
        	// 枚举左端点
            for (int i = 0; i + len - 1 < s.length(); i++) {
            	// 算出左右端点
                int l = i, r = i + len - 1;
                
                char left = s.charAt(l), right = s.charAt(r);
                
                if (len == 1) {
                    dp[l][r] = left == '*';
                } else if (len == 2) {
                    dp[l][r] = check(left, right);
                } else {
                    dp[l][r] |= check(left, right) && dp[l + 1][r - 1];
                    for (int j = 1; j < len; j++) {
                        dp[l][r] |= dp[l][l + j - 1] && dp[l + j][r];
                        // 发现找到一个合法替换方式了，直接退出，不必继续循环
                        if (dp[l][r]) {
                            break;
                        }
                    }
                }
            }
        }
        
        return dp[0][s.length() - 1];
    }
    
    private boolean check(char left, char right) {
        return left != ')' && right != '(';
    }
}

时间复杂度$O(n^3)$，空间$O(n^2)$。

法2：DFS。直接枚举每个'*'怎么处理即可，同时用一个变量记录前缀里左括号数量减去右括号数量的差。代码如下：

public class Solution {
    public boolean checkValidString(String s) {
        if (s.isEmpty()) {
            return true;
        }
        
        return dfs(0, s, 0);
    }
    
    private boolean dfs(int pos, String s, int count) {
        if (count < 0 || count > s.length() - pos) {
            return false;
        }
        if (pos == s.length()) {
            return count == 0;
        }
        
        for (int i = pos; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (ch == '(') {
                count++;
            } else if (ch == ')') {
                count--;
                if (count < 0) {
                    return false;
                }
            } else {
                return dfs(i + 1, s, count) || dfs(i + 1, s, count + 1) || dfs(i + 1, s, count - 1);
            }
        }
        
        return count == 0;
    }
}

时间复杂度指数级，空间$O(n)$。