leetcode笔记—Dynamic Programming

10. Regular Expression Matching (hard) #

正则表达式匹配：.和*

Implement regular expression matching with support for '.' and '*'.

'.' Matches any single character.
'*' Matches zero or more of the preceding element.

The matching should cover the entire input string (not partial).

The function prototype should be:
bool isMatch(const char *s, const char *p)

Some examples:
isMatch("aa","a") → false
isMatch("aa","aa") → true
isMatch("aaa","aa") → false
isMatch("aa", "a*") → true
isMatch("aa", ".*") → true
isMatch("ab", ".*") → true
isMatch("aab", "c*a*b") → true

// 递归
class Solution {
public:
    bool isMatch(string s, string p) {
        if (p.empty())
            return s.empty();
        if(p.size() > 1 && p[1] == '*')
            return isMatch(s, p.substr(2)) || (!s.empty() && (s[0] == p[0] || p[0] == '.') && isMatch(s.substr(1), p));
        else
            return !s.empty() && (s[0] == p[0] || p[0] == '.') && isMatch(s.substr(1), p.substr(1));
    }
};

// dp
class Solution {
public:
    bool isMatch(string s, string p) {
        int m = s.size(), n = p.size();
        vector<vector<bool>> dp(m + 1, vector<bool>(n + 1, false));
        dp[0][0] = 1;
        for (int i = 1; i <= m; ++i)
            dp[i][0] = 0;
        for (int i = 2; i <= n; ++i)
            dp[0][i] = p[i - 1] == '*' && dp[0][i - 2];
        for (int i = 1; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (p[j - 1] == '*')
                    dp[i][j] = dp[i][j - 2] || ((s[i - 1] == p[j - 2] || p[j - 2] == '.') && dp[i - 1][j]);
                else
                    dp[i][j] = dp[i - 1][j - 1] && (p[j - 1] == '.' || p[j - 1] == s[i - 1]);
            }
        }
        return dp[m][n];
    }
};

 

---

32. Longest Valid Parentheses (hard) #

最长的有效括号

Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring.

For "(()", the longest valid parentheses substring is "()", which has length = 2.

Another example is ")()())", where the longest valid parentheses substring is "()()", which has length = 4.

// stack
class Solution {
public:
    int longestValidParentheses(string s) {
        vector<int> st = {-1};
        int res = 0;
        for (int i = 0; i < s.size(); ++i) {
            if (s[i] == '(')
                st.push_back(i);
            else if (!st.empty() && s[st.back()] == '(')
                st.pop_back();
            else
                st.push_back(i);
        }
        st.push_back(s.size());
        for (int i = 1; i < st.size(); ++i)
            res = max(res, st[i] - st[i - 1] - 1);
        return res;
    }
};

// dp
class Solution {
public:
    int longestValidParentheses(string s) {
        int res = 0;
        vector<int> dp(s.size(), 0);
        for (int i = 1; i < s.size(); ++i) {
            if (s[i] == ')') {
                if (s[i - 1] == '(')
                    dp[i] = i > 2 ? dp[i - 2] + 2 : 2;
                else if (i - dp[i - 1] - 1 >= 0 && s[i - dp[i - 1] - 1] == '(')
                    dp[i] = dp[i - 1] + 2 + dp[i - dp[i - 1] - 2];
                res = max(res, dp[i]);
            }
        }
        return res;
    }
};

 

---

44. Wildcard Matching (hard) #

正则表达式匹配：?和*

Implement wildcard pattern matching with support for '?' and '*'.

'?' Matches any single character.
'*' Matches any sequence of characters (including the empty sequence).

The matching should cover the entire input string (not partial).

The function prototype should be:
bool isMatch(const char *s, const char *p)

Some examples:
isMatch("aa","a") → false
isMatch("aa","aa") → true
isMatch("aaa","aa") → false
isMatch("aa", "*") → true
isMatch("aa", "a*") → true
isMatch("ab", "?*") → true
isMatch("aab", "c*a*b") → false

 

// 递归：runtime error
class Solution {
public:
    bool isMatch(string s, string p) {
        if (p.empty())
            return s.empty();
        else if (p[0] == '?')
            return s.empty() ? false : isMatch(s.substr(1), p.substr(1));
        else if (p[0] == '*')
            return isMatch(s, p.substr(1)) || (!s.empty() && isMatch(s.substr(1), p));
        else
            return !s.empty() && s[0] == p[0] && isMatch(s.substr(1), p.substr(1));
    }
};