kniost

谁怕，一蓑烟雨任平生

0%

LeetCode 10. Regular Expression Matching

发表于 更新于 分类于
本文字数： 3.4k 阅读时长 ≈ 3 分钟
LeetCode 10. Regular Expression Matching

10. Regular Expression Matching

Difficulty: Hard

Given an input string (s) and a pattern (p), implement regular expression matching with support for '.' and '*'.

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

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

Note:

  • s could be empty and contains only lowercase letters a-z.
  • p could be empty and contains only lowercase letters a-z, and characters like . or *.

Example 1:

1
2
3
4
5
Input:
s = "aa"
p = "a"
Output: false
Explanation: "a" does not match the entire string "aa".

Example 2:

1
2
3
4
5
Input:
s = "aa"
p = "a*"
Output: true
Explanation:  '*' means zero or more of the precedeng  element, 'a'. Therefore, by repeating 'a' once, it becomes "aa".

Example 3:

1
2
3
4
5
Input:
s = "ab"
p = ".*"
Output: true
Explanation:  ".*" means "zero or more (*) of any character (.)".

Example 4:

1
2
3
4
5
Input:
s = "aab"
p = "c*a*b"
Output: true
Explanation:  c can be repeated 0 times, a can be repeated 1 time. Therefore it matches "aab".

Example 5:

1
2
3
4
Input:
s = "mississippi"
p = "mis*is*p*."
Output: false

Solution

Language: Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class Solution {
      public boolean isMatch(String s, String p) {
            if (s == null || p == null) {
                  return false;
           }
            if (s.length() == 0 && p.length() == 0) {
                  return true;
           }
            if (p.length() == 0) {
                  return false;
           }
            return matchStar(s, p, 0, 0);
     }
​
      private boolean match(char c, char p) {
            if (p == '.') {
                  return true;
           }
            return c == p;
     }
      
      private boolean matchStar(String s, String p, int indexS, int indexP) {
            if (indexP >= p.length()) {
                  return indexS >= s.length();
           }
            char c1 = p.charAt(indexP);
            if (indexP + 1 < p.length() && p.charAt(indexP + 1) == '*') {
                  if (indexS < s.length() && match(s.charAt(indexS), c1)) {
                        return matchStar(s, p, indexS, indexP + 2) 
                              || matchStar(s, p, indexS + 1, indexP) 
                    // 一个疑问是这里indexP + 2才对，为何indexP + 1也可以，并且更快10倍
                              || matchStar(s, p, indexS + 1, indexP + 1);
                 } else {
                        return matchStar(s, p, indexS, indexP + 2);
                 }
           } else {
                  if (indexS < s.length() && match(s.charAt(indexS), c1)) {
                        return matchStar(s, p, indexS + 1, indexP + 1);
                 }
           }
            return false;
     }
}

动态规划

使用dp[i][j]代表s的前i位和p的前j位匹配情况

  1. 如果 p.charAt(j) == s.charAt(i) 则 dp[i + 1][j + 1] = dp[i][j];
  2. 如果 p.charAt(j) == '.' 则 dp[i + 1][j + 1] = dp[i][j];
  3. 如果 p.charAt(j) == '*'，则分两种情况：
    1. 如果p的j-1位与s的i位不匹配：
      那么把星号前的字母当成未出现，dp[i + 1][j + 1] = dp[i + 1][j - 1]
    2. 否则星号有三种情况，即匹配0次，匹配1次和匹配多次， 
      1
      2
      3
      dp[i + 1][j + 1] = dp[i][j + 1] // 匹配多次
                      || dp[i + 1][j - 1] //匹配0次
                      || dp[i + 1][j] // 匹配1次
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
class Solution {
    public boolean isMatch(String s, String p) {
        if (s == null || p == null) {
            return false;
        }
        if (s.length() == 0 && p.length() == 0) {
            return true;
        }
        if (p.length() == 0) {
            return false;
        }
        boolean[][] dp = new boolean[s.length() + 1][p.length() + 1];
        dp[0][0] = true;
        for (int i = 1; i < p.length(); i++) {
            if (p.charAt(i) == '*' && dp[0][i - 1]) {
                dp[0][i + 1] = true;
            }
        }
        for (int i = 0; i < s.length(); i++) {
            for (int j = 0; j < p.length(); j++) {
                if (p.charAt(j) == '.' || p.charAt(j) == s.charAt(i)) {
                    dp[i + 1][j + 1] = dp[i][j];
                }
                if (p.charAt(j) == '*') {
                    if (p.charAt(j - 1) == '.' || p.charAt(j - 1) == s.charAt(i)) {
                        dp[i + 1][j + 1] = dp[i + 1][j] || dp[i][j + 1] || dp[i + 1][j - 1];
                    } else {
                        dp[i + 1][j + 1] = dp[i + 1][j - 1];
                    }
                }
            }
        }
        return dp[s.length()][p.length()];
        
    }
}