正则表达式（包含 *, ?) 的动态规划算法

下面是我自己的解答

#include "stdafx.h"
#include <stdio.h>
#include <string.h>
#define MAX_LEN 128

bool match(char *S, char *P)
{
	bool F[MAX_LEN][MAX_LEN];

	int lenS = strlen(S);
	int lenP = strlen(P);

	for (int i = 0; i<MAX_LEN; i++)
	{
		for (int j = 0; j<MAX_LEN; j++)
		{
			F[i][j] = false;
		}
	}

	F[0][0] = true;


	for (int i = 1; i <=lenP; i++)
	{
		for (int j = 1; j<=lenS; j++)
		{
			if (F[i-1][j-1])
			{
				if (S[j-1] == P[i-1] || P[i-1] == '?' || P[i-1] == '*')
				{
					F[i][j] = true;
					continue;
				}
			}

			if (F[i-1][j])
			{
				if (P[i-1] == '*')
				{
					F[i][j] = true;
					continue;
				}

			}

			if (F[i][j-1])
			{
				if (P[i-1] == '*')
				{
					F[i][j] = true;
					continue;
				}
			}
		}
	}
	return F[lenP][lenS];
}




int _tmain(int argc, _TCHAR* argv[])
{
	char *S = "CISCO";
	char *P = "*C?";

	bool isMatch = match(S, P);

	if (isMatch)
	{
		printf("Match\n");
	}
	else
	{
		printf("No Match\n");
	}
	return 0;
}
网上有一个更详细的解答：

网上有一个更详细的描述

参考：http://blog.csdn.net/lifajun90/article/details/10582733

解法一：

由于以前做过一个类似的题目http://soj.me/1197,所以我的第一印象就是用动态规划，具体思路如下：

用dp[i][j]表示字符串s的前i个字符和字符串p的前j个字符是否匹配，那么状态转移情况如下：

if (dp[i-1][j-1] && (s[i] == p[j] || '?' == p[j])) dp[i][j] = true, 即如果前i-1和前j-1个字符匹配，当前字符也匹配，那么前i个和前j个也匹配。

如果p的当前字符为'*'号，那么可以分两种情况：

(1) 如果dp[i-1][j-1]，那么p的前j个字符和s的前k(i-1<=k<=len_s)个字符都匹配，注意这里有一个i-1，因为*可以匹配空串。

(2)如果dp[i][j-1]，即s的前i个字符和字符串p的前j-1个字符，那么p的前j个字符和s的前k(i<=k<=len_s)个字符匹配，注意这里没有i-1，因为这是让*去匹配i后面的字符串。

这种解法的时间复杂度和空间复杂度都为O(N^2)，所以在leetcode上只能过小数据不能过大数据。

具体实现代码如下：

[cpp]  view plain copy

1. //dp解法  
2. const int N = 105;  
3. bool dp[N][N];  
4.   
5. class Solution {  
6. public:  
7.   bool isMatch(const char *s, const char *p) {  
8.     // Start typing your C/C++ solution below  
9.     // DO NOT write int main() function  
10.     if (*s == '\0') {  
11.       while(*p == '*') p++;  
12.       return *p == '\0';  
13.     }  
14.     if (*p == '\0') return false;  
15.   
16.     memset(dp, false, sizeof dp);  
17.     dp[0][0] = true;  
18.     int len_s = strlen(s), len_p = strlen(p);  
19.     for (int j = 1; j <= len_p; j++) {  
20.       for (int i = 1; i <= len_s; i++) {  
21.         if (dp[i-1][j-1] && (s[i-1] == p[j-1] || '?' == p[j-1])) dp[i][j] = true;  
22.         if ('*' == p[j-1]) {  
23.           if (dp[i-1][j-1]) {  
24.             for (int k = i-1; k <= len_s; k++) dp[k][j] = true;  
25.             break;  
26.           } else if (dp[i][j-1]) {  
27.             for (int k = i; k <= len_s; k++) dp[k][j] = true;  
28.             break;  
29.           }  
30.         }  
31.       }  
32.     }  
33.     return dp[len_s][len_p];  
34.   }  
35. };  

解法二(递归解法)：

解法一不能过大数据的原因在于两层for循环其实执行了多余的匹配过程，其实对于这种匹配来说如果*s和*p相等的话我们可以直接把指针往后移动，从而把数据规模缩小。这种做法的难点同样在对*号的处理上，因为*号可以匹配多个字符，所以在递归解法中需要回溯。

因为递归和回溯的代价都太高，所以该解法也只能过小数据，不能过大数据。

具体代码实现如下：

[cpp]  view plain copy

1. //递归解法  
2. class Solution {  
3. public:  
4.   bool isMatch(const char *s, const char *p) {  
5.     // Start typing your C/C++ solution below  
6.     // DO NOT write int main() function  
7.     if (*s == '\0') {  
8.       while(*p == '*') p++;  
9.       return *p == '\0';  
10.     }  
11.     if (*p == '\0') return false;  
12.   
13.     while (*s && *p) {  
14.       if (*s != *p) {  
15.         if (*p == '?') s++, p++;  
16.         else if (*p == '*') {  
17.           while(*p == '*') p++;//跳过连续的*号  
18.           if (*p == '\0') return true;//如果跳过*号就到达结尾，那么是匹配的  
19.           while (*s) {  
20.             if (isMatch(s, p)) return true;//不停的尝试  
21.             s++;  
22.           }  
23.         } else return false;  
24.       } else s++, p++;  
25.     }  
26.     return isMatch(s, p);  
27.   }  
28. };  

解法三(非递归解法)

解法三其实是对解法二的改进，即把算法二改为非递归，但是解法二中的递归并不是尾递归，如果要改为非递归的话为了回溯就需要自己构造堆栈，幸运的是，在这里我们并不需要构造堆栈，而只需要通过两个变量pre_s和pre_p来保存上一次它们开始比较的位置，然后在回溯的时候我们从上一次比较的位置的后一个位置开始比较。

那么这么做的原理何在呢？首先，如果p串中只有一个*号，那么这么做无疑是正确的，那么对于有多个*号的情况，我们来看一个例子，s="accbcbccx", p="a*b*d"，按解法二第一个*号其实是匹配了cc，即accb和a*b匹配了，剩下的cbccx交给*d去匹配，试想如果cbccx和*d匹配失败了，我们回溯到上一个*号去匹配是否能够成功呢？还是不能！因为*是可以匹配任意长度的，就算回到上一次的*号位置，让accbcb去和a*b匹配了，剩下的ccx和*d还是不能匹配，因为其实第二个*既可以匹配ccx也可以匹配cbccx，即是说后面的*号可以代替前面的*号的作用。总结一下，我们得出结论，在遇到*好不匹配时，我们直接回到上一次开始比较的位置的后一个位置开始比较就可以了，如果能匹配必然能找到匹配，如果不能匹配，那么再回溯也是没用的。而这也是解法三比解法二除了递归开销以外更节省时间的地方。

该解法可以过大数据。

具体代码实现如下：

[cpp]  view plain copy

1. //非递归解法  
2. class Solution {  
3. public:  
4.   bool isMatch(const char *s, const char *p) {  
5.     // Start typing your C/C++ solution below  
6.     // DO NOT write int main() function  
7.     const char *pre_s = s, *pre_p = p;//保存上一次开始匹配的位置  
8.     bool has_star = false;  
9.   
10.     while (*s) {  
11.       if (*s != *p) {  
12.         if (*p == '?') s++, p++;  
13.         else if (*p == '*') {  
14.           has_star = true;  
15.           while (*p == '*') p++;  
16.           if (*p == '\0') return true;  
17.           pre_s = s, pre_p = p;//置上一个开始比较的位置  
18.         } else if (has_star) {  
19.           pre_s++;  
20.           s = pre_s, p = pre_p;//恢复到上一次比较的下一个位置  
21.         } else return false;  
22.       } else s++, p++;  
23.     }  
24.   
25.     while (*p == '*') p++;  
26.     return *p == '\0';  
27.   }  
28. };  

第一题的解法到此结束。

下面来看第二题的解法：

首先第二题和第一题还是有些类似的，但是区别在于这次是*号之前的字符可以出现多次，比如说a*b可以和ab也可以和aab匹配，甚至也可以和b匹配，因为a可以出现0次。

那么该题的解法就和第一题类似了，在比较的时候首先判断*(p+1)是否是*号，如果是就需要递归回溯判断，如果不是就挨个比较就行了。

具体代码实现如下：

[cpp]  view plain copy

1. class Solution {  
2. public:  
3.   bool isMatch(const char *s, const char *p) {  
4.     // Start typing your C/C++ solution below  
5.     // DO NOT write int main() function      
6.     if (*p == '\0') return *s == '\0';  
7.   
8.     if (*(p+1) == '*') {  
9.       while (*s && (*s == *p || '.' == *p)) {//如果*s和*p相等，那么*p可以匹配多个s中的字符  
10.         if (isMatch(s, p+2)) return true;  
11.         s++;  
12.       }  
13.       return isMatch(s, p+2);//如果不等，那么只有跳过*p了  
14.     } else {  
15.       return (*s == *p || (*s && '.' == *p)) && isMatch(s+1, p+1);//继续递归匹配  
16.     }  
17.   }  
18. };  

可能在leetcode上的测试数据比较弱，该递归算法是可以过大数据的。

那么这个题目可不可以像第一题那样改为非递归而又只需保存上一个开始匹配的位置呢？答案是不能！我们来看个例子s="cbcbc", p=".*b*c"，首先按照上述递归算法c和.*匹配了，b和b*匹配了，剩下cbc去和c匹配，显然不匹配，如果回到上一次的*号处，让cbc继续去和b*c匹配，肯定也是不能匹配的，如果只保存了上一个开始匹配的位置，那么该算法就会判断为不能匹配了，可实际上s和p是可以匹配的，让cbc去和.*匹配，剩下的bc和b*c匹配就可以了。因此这种设想是行不通的。分析一下，上一题中这种做法能行得通，而这次行不通的原因在于，上一题中的*可以匹配任何字串，而这一题中的b*其实只能匹配以b开头的字符串或者空串，这正是区别之所在。

所以如果这次还要改为非递归的话，就需要自己构造堆栈了！(代码没实现)

-----over------

参考：

http://blog.csdn.net/hopeztm/article/details/7992253

http://fisherlei.blogspot.com/2013/01/leetcode-wildcard-matching.html