dfs 正则表达式

192. 通配符匹配

中文

English

判断两个可能包含通配符“？”和“*”的字符串是否匹配。匹配规则如下：

• '?' 可以匹配任何单个字符。
• '*' 可以匹配任意字符串（包括空字符串）。

两个串完全匹配才算匹配成功。

样例

样例1

输入:
"aa"
"a"
输出: false

输出2

输入:
"aa"
"aa"
输出: true

输出3

输入:
"aaa"
"aa"
输出: false

输出4

输入:
"aa"
"*"
输出: true
说明: '*' 可以替换任何字符串

输出5

输入:
"aa"
"a*"
输出: true

样例6

输入:
"ab"
"?*"
输出: true
说明: '?' -> 'a' '*' -> 'b'

样例7

输入:
"aab"
"c*a*b"
输出: false

class Solution:
    """
    @param s: A string
    @param p: A string includes "?" and "*"
    @return: is Match?
    """
    def isMatch(self, s, p):
        # write your code here
        self.cache = {}
        return self.helper(s, p, s_at=len(s)-1, p_at=len(p)-1)

    def helper(self, s, p, s_at, p_at):
        if (s_at, p_at) in self.cache:
            return self.cache[(s_at, p_at)]

        if p_at < 0:
            return s_at < 0

        if s_at < 0:
            for i in range(0, p_at+1):
                if p[i] != "*":
                    return False
            return True

        if p[p_at] == '?':
            is_match = self.helper(s, p, s_at-1, p_at-1)
        elif p[p_at] == '*':
            is_match = self.helper(s, p, s_at-1, p_at) or \
                    self.helper(s, p, s_at, p_at-1)
        else:
            is_match = s_at >= 0 and s[s_at]==p[p_at] and \
                   self.helper(s, p, s_at-1, p_at-1)
        self.cache[(s_at, p_at)] = is_match
        return is_match

注意 如果不用cache的话会超时。

更复杂一点的题目：

154. 正则表达式匹配

中文

English

实现支持'.'和'*'的正则表达式匹配。

'.'匹配任意一个字母。

'*'匹配零个或者多个前面的元素。

匹配应该覆盖整个输入字符串，而不仅仅是一部分。

需要实现的函数是：bool isMatch(string s, string p)

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

样例

样例 1:

输入："aa"，"a"
输出：false
解释：
无法匹配

样例 2:

输入："aa"，"a*"
输出：true
解释：
'*' 可以重复 a

class Solution:
    """
    @param s: A string
    @param p: A string includes "." and "*"
    @return: A boolean
    """
    def isMatch(self, s, p):
        # write your code here
        self.cache = {}
        return self.helper(s, p, s_at=len(s)-1, p_at=len(p)-1)

    def helper(self, s, p, s_at, p_at):
        if (s_at, p_at) in self.cache:
            return self.cache[(s_at, p_at)]

        if p_at < 0:
            return s_at < 0
        else:
            if s_at < 0:
                for i in range(p_at, -1, -2):
                    if p[i] != '*':
                        return False
                return True

        if p[p_at] == '.':
            is_match = self.helper(s, p, s_at-1, p_at-1)
        elif p[p_at] == '*':
            matched_once = (p_at > 0 and (p[p_at-1] == '.' or p[p_at-1] == s[s_at])) and \
                self.helper(s, p, s_at-1, p_at)
            matched_none = self.helper(s, p, s_at, p_at-2)
            is_match = matched_once or matched_none
        else:
            is_match = s_at >= 0 and s[s_at]==p[p_at] and \
                   self.helper(s, p, s_at-1, p_at-1)
        self.cache[(s_at, p_at)] = is_match
        return is_match

算法思路整体上和上面题目一样，唯一的区别就是pattern -2，还有对于空串的匹配截止条件。

"" 匹配类似"a*b*c*"这样的模式。

当然，从前往后的匹配解法也是可以的，也就是匹配的时候pattern往前多看一步看是不是*来决定走一步还是走两步，参考代码：

class Solution:
    """
    @param s: A string
    @param p: A string includes "?" and "*"
    @return: is Match?
    """
    def isMatch(self, source, pattern):
        return self.is_match_helper(source, 0, pattern, 0, {})

    # source 从 i 开始的后缀能否匹配上 pattern 从 j 开始的后缀
    # 能 return True
    def is_match_helper(self, source, i, pattern, j, memo):
        if (i, j) in memo:
            return memo[(i, j)]

        # source is empty
        if len(source) == i:
            return self.is_empty(pattern[j:])

        if len(pattern) == j:
            return False

        if j + 1 < len(pattern) and pattern[j + 1] == '*':
            matched = self.is_match_char(source[i], pattern[j]) and self.is_match_helper(source, i + 1, pattern, j, memo) or \
                self.is_match_helper(source, i, pattern, j + 2, memo)
        else:
            matched = self.is_match_char(source[i], pattern[j]) and \
                self.is_match_helper(source, i + 1, pattern, j + 1, memo)

        memo[(i, j)] = matched
        return matched

    def is_match_char(self, s, p):
        return s == p or p == '.'

    def is_empty(self, pattern):
        if len(pattern) % 2 == 1:
            return False

        for i in range(len(pattern) // 2):
            if pattern[i * 2 + 1] != '*':
                return False
        return True

829. 字模式 II

中文

English

给定一个pattern和一个字符串str，查找str是否遵循相同的模式。
这里遵循的意思是一个完整的匹配，在一个字母的模式和一个非空的单词str之间有一个双向连接的模式对应。(如果a对应s，那么b不对应s。例如，给定的模式= "ab"， str = "ss"，返回false）。

样例

样例1

输入:
pattern = "abab"
str = "redblueredblue"
输出: true
说明: "a"->"red","b"->"blue"

样例2

输入:
pattern = "aaaa"
str = "asdasdasdasd"
输出: true
说明: "a"->"asd"

样例3

输入:
pattern = "aabb"
str = "xyzabcxzyabc"
输出: false

注意事项

您可以假设模式和str只包含小写字母

class Solution:
    """
    @param pattern: a string,denote pattern string
    @param str: a string, denote matching string
    @return: a boolean
    """
    def wordPatternMatch(self, pattern, str):
        # write your code here
        self.word_dict = {}
        self.word_match = {}
        return self.dfs(pattern, str)

    def dfs(self, pattern, s):
        if not pattern:
            return not s

        if not s:
            return not pattern

        pattern_char = pattern[0]
        if pattern_char in self.word_dict:
            word_to_match = self.word_dict[pattern_char]
            return s[:len(word_to_match)] == word_to_match and \
                self.dfs(pattern[1:], s[len(word_to_match):])
        else:
            for i in range(0, len(s)):
                word = s[:i+1]
                if word in self.word_match:
                    continue
                self.word_dict[pattern_char] = word
                self.word_match[word] = pattern_char
                if self.dfs(pattern[1:], s[i+1:]):
                    return True
                del self.word_dict[pattern_char]
                del self.word_match[word]
            return False

    """
         这里我们为什么需要一个额外的 Set<String> 呢？ 

			一个好的测试用例是:
			pattern:    "bdpbibletwuwbvh"
			str:        "aaaaaaaaaaaaaaa"

		 这里第一次执行时， map中匹配了 b -> a
		 递归进去以后第二次执行时，d 没有在 map 中，所以跳过了map的匹配检测，
		 所以进入循环体， 这时第二个word 又是 a, 按道理 a 应该被 b 匹配并且之前应该在map.containsKey的检查中跳出， 但现在并没有跳出，而是试图绑匹配给另一个pattern的字母 d,
		 很明显 b != d 重复绑定不是正确结果， 所以需要continue掉这次尝试。
    """