## LeetCode: Wildcard Matching 解题报告

Wildcard Matching
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

SOLUTION 1:

DP.

flag[i][j]=flag[i-1][j-1];

flag[i][j]=flag[i-1][j]||flag[i-1][j-1]||……||flag[i-1][0]。

flag[i][j-1]=flag[i-1][j-1]||flag[i-1][j-2]||……||flag[i-1][0]

flag[i][j]==flag[i-1][j]||flag[i][j-1],所以综合递推公式如下：

 1 public boolean isMatch1(String s, String p) {
2         if (s == null || p == null) {
3             return false;
4         }
5
6         int lens = s.length();
7         int lenp = p.length();
8
9         // 创建一个Dp二维数组
10         boolean[][] D = new boolean[lens + 1][lenp + 1];
11
12         boolean flag = false;
13
14         for (int i = 0; i <= lens; i++) {
15             flag = false;
16             for (int j = 0; j <= lenp; j++) {
17                 // both is empty.
18                 if (i == 0 && j == 0) {
19                     D[i][j] = true;
20                     flag = true;
21                     continue;
22                 }
23
24                 // if P is empty, s is not empty, it is false.
25                 if (j == 0) {
26                     D[i][j] = false;
27                     continue;
28                 }
29
30                 // if S is empty, P is not empty
31                 if (i == 0) {
32                     D[i][j] = D[i][j - 1] && p.charAt(j - 1) == '*';
33                 } else {
34                     D[i][j] = (matchChar(s.charAt(i - 1), p.charAt(j - 1)) && D[i - 1][j - 1])
35                       || (p.charAt(j - 1) == '*' && (D[i][j - 1] || D[i - 1][j]));
36                 }
37
38                 if (D[i][j]) {
39                     flag = true;
40                 }
41
42                 // Greedy. 在此即可以退出，因为* 可以匹配余下的所有的字符串。
43                 if (D[i][j] && p.charAt(j - 1) == '*' && j == lenp) {
44                     return true;
45                 }
46             }
47
48             if (!flag) {
49                 return false;
50             }
51         }
52
53         return D[lens][lenp];
54     }
55
56     public static boolean matchChar(char c, char p) {
57         return (p == '?' || p == c);
58     }
59 }
View Code

SOLUTION 2:

1. 二个指针i, j分别指向字符串、匹配公式。

2. 如果匹配，直接2个指针一起前进。

3. 如果匹配公式是*，在字符串中依次匹配即可。

下面是迭代程序，要熟悉这个思维：记录上一次开始比较的位置，如图：

下面程序是直接使用指针记录位置(JAVA中就使用一个index就好了）

 1     public static boolean matchChar(char c, char p) {
2         return (p == '?' || p == c);
3     }
4
5     public static boolean isMatch(String s, String p) {
6         if (s == null || p == null) {
7             return false;
8         }
9
10         int indexS = 0;
11         int indexP = 0;
12
13         int lenS = s.length();
14         int lenP = p.length();
15
16         int preS = 0;
17         int preP = 0;
18
19         boolean back = false;
20
21         while (indexS < lenS) {
22             if (indexP < lenP && matchChar(s.charAt(indexS), p.charAt(indexP))) {
23                 indexS++;
24                 indexP++;
25             } else if (indexP < lenP && p.charAt(indexP) == '*') {
26                 while (indexP < lenP && p.charAt(indexP) == '*') {
27                     indexP++;
28                 }
29
30                 //P的最后一个是 *，表示可以匹配任何字符串
31                 if (indexP == lenP) {
32                     return true;
33                 }
34
35                 // 记录下这个匹配位置。
36                 back = true;
37                 preS = indexS;
38                 preP = indexP;
39             } else if (back) {
40                 indexS = ++preS;
41                 indexP = preP;
42             } else {
43                 return false;
44             }
45         }
46
47         // 跳过末尾的所有的*.
48         while (indexP < lenP && p.charAt(indexP) == '*') {
49             indexP++;
50         }
51
52         if (indexS == lenS && indexP == lenP) {
53             return true;
54         }
55
56         return false;
57     }
View Code

Version 2:

 1 public class Solution {
2     public boolean isMatch(String s, String p) {
3         // 2030.
4         if (s == null || p == null) {
5             return false;
6         }
7
8         int indexS = 0;
9         int indexP = 0;
10
11         int lenS = s.length();
12         int lenP = p.length();
13
14         int preP = -1;
15         int preS = -1;
16
17         while (indexS < lenS) {
18             if (indexP < lenP && matchChar(p.charAt(indexP), s.charAt(indexS))) {
19                 indexP++;
20                 indexS++;
21             } else if (indexP < lenP && p.charAt(indexP) == '*') {
22                 preS = indexS;
23                 preP = indexP;
24
25                 // Move to the next character of P.
26                 indexP++;
27             } else if (preP != -1) {
28                 indexP = preP;
29                 indexP++;
30
31                 preS++;
32                 indexS = preS;
33             } else {
34                 return false;
35             }
36         }
37
38         while (indexP < lenP) {
39             if (p.charAt(indexP) != '*') {
40                 return false;
41             }
42             indexP++;
43         }
44
45         return true;
46     }
47
48     public boolean matchChar(char p, char s) {
49         return s == p || p == '?';
50     }
51 }
View Code

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/dp/IsMatch.java

http://www.ninechapter.com/solutions/

REF:

http://m4tiku.duapp.com/report?pid=123

http://blog.csdn.net/kenden23/article/details/17123497

posted on 2014-11-23 09:22 Yu's Garden 阅读(...) 评论(...) 编辑 收藏

• 随笔 - 166
• 文章 - 1
• 评论 - 71
• 引用 - 0