題目描述
Given an input string (s) and a pattern (p), implement regular expression matching with support for '.' and '*'.
'.' 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:
Input:
s = "aa"
p = "a"
Output: false
Explanation: "a" does not match the entire string "aa".
Example 2:
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:
Input:
s = "ab"
p = ".*"
Output: true
Explanation: ".*" means "zero or more (*) of any character (.)".
Example 4:
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:
Input:
s = "mississippi"
p = "mis*is*p*."
Output: false
解題思路
題目意思很明確，給定一個正則表達式判斷輸入的字符串是否能與該表達式完全匹配。比較特殊的是，這個正則表達式中只有字母、小數點以及星號。
先來梳理一下這三種字符的意義。字母無需多解釋：匹配和它自己一樣的字符；小數點表示匹配任意字符；而*不單獨使用，跟在字母或者小數點后，表示匹配0個到多個 * 前字符。
看起來像是一個最長遞增字串之類的問題，即s的子串s'能匹配到p的子串p'，慢慢擴展這個s'的長度，看下是否能完全匹配。話雖如此，但狀態轉移還是比較復雜的過程，不妨先處理一下邊界情況：
當正則串p的長度和s的長度都為0的時候，不需要考慮子串的問題，直接返回true；當p的長度為0而s的長度不為0時，返回false；當s的長度為0而p的長度不為0，考慮p是否可以匹配空串，即：p是否為a*b*....z*這樣的結構，如果是則返回true，反之則返回false。
這樣，邊界情況就考慮完畢了，我們可以來設計狀態轉移方程了。假設s'能匹配到p'，則將p'的末尾位置的值設為true（同一個s'可以匹配到若干個p'）。假設s''比s'多一位，這時我們可以這樣找p''：找到所有p'，對于任意一個p'，能不能加入后一個字符變成p''，并且讓s''成功匹配。找到這樣的p''之后，我們考慮p''是否為*結尾，若是*結尾，則將后續所有的a*b*...z*這樣連續的結構上的*的位置都變為true；若不是，則找后續$a*b*...z*這樣連續的結構上的 *置為true（因為a*可以匹配一個空串，即p''可以經過邊到達的串也是可以匹配s''的）。重復進行這樣的迭代，直到p'集合為空，這時退出并返回false（有一個字符無法在正則表達式中找到下一個匹配）；重復到s''==s時，返回p''最后一個位置上的值。
簡單地說，這個算法其實是一個簡化的NFA模型，即不停的加入字符串s中的字符，根據上次找到的狀態集尋找這次迭代要找的狀態集，當所有字符輸入完畢，并存在一個狀態是終止狀態（p''最后一個位置上的值為true）時返回true，反之則返回false。需要注意的是，由于正則中有*的存在，它會讓匹配到的新狀態自動跳轉到別的狀態（即NFA中的邊），使狀態數增加。
這次用的算法其實跟NFA比較相似，使用動態規劃遞歸的算法可以讓題目變得更加簡單，詳情可以參考Leetcode中的solution以及大家的discussion。
時間復雜度分析
遍歷整個字符串s（長度為sl），正則表達式長度為pl，每個字符最多對應pl個狀態，因此復雜度為O(pl * sl)。
空間復雜度分析
由狀態數決定O(pl * sl)，可以適當優化。
源碼
class Solution {
public:
bool isMatch(string s, string p) {
if (p.length() == 0 && s.length() == 0) {
return true;
}
if (p.length() == 0) {
return false;
}
if (s.length() == 0) {
for (int i = 0; i < p.length(); ++i) {
if (p[i] != '*' && i + 1 < p.length() && p[i + 1] != '*') {
return false;
} else if (p[i] != '*' && i + 1 == p.length()) {
return false;
}
}
return true;
}
if (p.length() == 1) {
return (p[0] =='.' || p[0] == s[0]) && s.length() == 1;
}
int dp[100][100] = {0};
for (int j = 0; j < s.length(); ++j) {
for (int i = 0; i < p.length(); ++i) {
dp[0][i] = 0;
}
}
for (int i = 0; i < p.length(); ++i) {
if (p[i] == '*') {
dp[0][i] = 1;
continue;
} else {
if (i != p.length() - 1) {
if (p[i + 1] == '*') {
dp[0][i + 1] = 1;
} else {
dp[0][i] = (p[i] == s[0] || p[i] == '.');
if (dp[0][i]) {
int j = i + 2;
while (j < p.length()) {
if (p[j] == '*') {
dp[0][j] = 1;
j += 2;
} else {
break;
}
}
j = i + 1;
if (p[j] == '*') {
while (j < p.length()) {
if (p[j] == '*') {
dp[0][j] = 1;
j += 2;
} else {
break;
}
}
}
}
break;
}
if (p[i] == s[0] || p[i] == '.') {
dp[0][i] = 1;
if (dp[0][i]) {
int j = i + 2;
while (j < p.length()) {
if (p[j] == '*') {
dp[0][j] = 1;
j += 2;
} else {
break;
}
}
j = i + 1;
if (p[j] == '*') {
while (j < p.length()) {
if (p[j] == '*') {
dp[0][j] = 1;
j += 2;
} else {
break;
}
}
}
}
}
} else {
dp[0][i] = (p[i] == s[0] || p[i] == '.');
}
}
}
for (int i = 1; i < s.length(); ++i) {
char target = s[i];
bool flag = false;
for (int j = 0; j < p.length(); ++j) {
if (dp[i - 1][j] == 1 && j != p.length() - 1) {
if (p[j + 1] == '.' || p[j + 1] == s[i]) {
dp[i][j + 1] = 1;
if (j + 2 < p.length() && p[j + 2] == '*') {
dp[i][j + 2] = 1;
int next = j + 2 + 2;
while (next < p.length()) {
if (p[next] == '*') {
dp[i][next] = 1;
next += 2;
} else {
break;
}
}
}
int next = j + 1 + 2;
while (next < p.length()) {
if (p[next] == '*') {
dp[i][next] = 1;
next += 2;
} else {
break;
}
}
flag = true;
} else if ((p[j] == '.' || p[j] == s[i]) && j < p.length() - 1 && p[j + 1] == '*') {
flag = true;
dp[i][j] = 1;
dp[i][j + 1] = 1;
int next = j + 1 + 2;
while (next < p.length()) {
if (p[next] == '*') {
dp[i][next] = 1;
next += 2;
} else {
break;
}
}
}
}
}
if (!flag) {
return false;
}
}
return dp[s.length() - 1][p.length() - 1];
}
};
