010.Regular_Expression_Matching (Hard)

連結：

題意：

給一個原串和一個正則表示式，問能不能匹配。

分析：

1. 偷懶的方法是直接用語言自帶的正則實現。(Python 又是一句話 =w=)
2. 用 DFS 的方法
3. 可以用 DP 的方法
   • 用陣列 DP :dp[i][j] 表示 s[0..i] 和 p[0..j] 是否 match，當 p[j] != '*'，b[i + 1][j + 1] = b[i][j] && s[i] == p[j] ，當p[j] == '*' 要再分類討論，具體可以參考 DP C++，還可以壓縮下把 dp 降成一維：參考這裡
   • 用記憶化，就是把算過的結果儲存下來，下次就不用再算了

程式碼：

C++: (DFS)

class Solution {
public:
    bool isMatch(const char *s, const char *p) {
		if (!p[0])
			return !s[0];

		int slen = strlen(s), plen = strlen(p);
		if (plen == 1 || p[1] != '*')
			return slen && (p[0] == '.' || s[0] == p[0])
				&& isMatch(s + 1, p + 1);
		while (s[0] && (p[0] == '.' || s[0] == p[0]))
			if (isMatch(s++, p + 2))
				return true;
		return isMatch(s, p + 2);
	}
};
 

Java: (陣列 DP)

public class Solution {

    public boolean isMatch(String s, String p) {
        int lens = s.length();
        int lenp = p.length();
        if (lens == 0 && lenp == 0)
            return true;

        // init
        boolean[][] dp = new boolean[2][lenp + 1];
        dp[0][0] = dp[1][0] = true;
        for (int j = 2; j <= lenp; ++j) {
            if (p.charAt(j - 1) == '*' && dp[0][j - 2]) {
                dp[0][j] = dp[1][j] = true;
            }
        }

        // dp
        for (int i = 1; i <= lens; ++i) {
            dp[i&1][0] = false;
            for (int j = 1; j <= lenp; ++j) {
                dp[i&1][j] = ((p.charAt(j - 1) == s.charAt(i - 1) || p.charAt(j - 1) == '.') && dp[1-(i&1)][j - 1])
                        || p.charAt(j - 1) == '*' && (p.charAt(j - 2) == s.charAt(i - 1) || p.charAt(j - 2) == '.') && dp[1-(i&1)][j]
                        || (j >= 2 && p.charAt(j - 1) == '*' && dp[i&1][j - 2]);
            }
        }

        return dp[lens&1][lenp];
    }
}
 

Python: (記憶化 DP)

class Solution:
    cache = {}
    # @return a boolean
    def isMatch(self, s, p):
        if (s, p) in self.cache:
            return self.cache[(s, p)]

        if not p:
            return not s

        if len(p) == 1 or p[1] != '*':
            self.cache[(s[1:], p[1:])] = self.isMatch(s[1:], p[1:])
            return len(s) > 0 and (p[0] == '.' or s[0] == p[0]) \
                and self.cache[(s[1:], p[1:])]
        while s and (p[0] == '.' or s[0] == p[0]):
            self.cache[(s, p[2:])] = self.isMatch(s, p[2:])
            if self.cache[(s, p[2:])]:
                return True
            s = s[1:]
        self.cache[(s, p[2:])] = self.isMatch(s, p[2:])
        return self.cache[(s, p[2:])]

Python: (用 regex)

class Solution:
    # @return a boolean
    def isMatch(self, s, p):
        return re.match('^' + p + '$', s) != None