LeetCode (10): Regular Expression Matching [HARD]
https://leetcode.com/problems/regular-expression-matching/
【描述】
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).
Some examples:
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
【中文描述】
给两个字符串：s和p. p是正则表达式串，其中包含有三种字符：普通字符、'.'、'*'。要求实现方法，返回p是否能够匹配s.
其中：
'.'可以匹配s中任意字符。
'*'是个控制字符，在'*'前的字符在s中可以出现0或者无限次。
题目要求全部匹配，不能部分匹配。
例子：
isMatch("aa","a") → false //解释：s中2个a，而p中一个普通字符a，显然不匹配
isMatch("aa","aa") → true
isMatch("aaa","aa") → false
isMatch("aa", "a*") → true //解释：s中2个a，而p中有'a*'，根据题意，a可以出现无数次，所以是匹配的
isMatch("aa", ".*") → true //解释：由于'.'可以代替任意字符，所以'.*'的意思就是任意字符出现任意次数，所以肯定可以匹配aa
isMatch("ab", ".*") → true //同上，ab也能匹配
isMatch("aab", "c*a*b") → true //解释：c在s中没有出现，但是c*是可以匹配的。然后aa匹配了a*， 最后的b互相匹配。 所以整体匹配
————————————————————————————————————————————————————————————
【初始思路】
刚开始没觉得是hard题，就觉得给2个指针，一个指s，一个指p。然后从前往后一步步比较就行了。无非就是比较当前位的时候兼顾后一位的情况，注意边界条件，仔细写应该不会出错。先写了一个，一提交wrong answer了。 用例是这样的：
s="aabbbcd", p="a*b*bbbcd"
显然，s和p是匹配的。但是用我上面的方法，就绝对匹配不成功。因为，p中的b*会直接和S中的bbb全部匹配，然后p中剩下的bbb就要和cd匹配，返回false。换句话说，我上面的算法是一条路走到黑，成功就成功，失败就失败。根本不考虑是否还有其他可能性！
【重整思路】
看到这个用例，我才反应过来，我太naive了，太没有程序猿的知觉了。事实上，仔细想想就能发现，这个题是需要回溯考虑的。可能按照s当前位和p中某'普通字符+*'模式比较是匹配的，到结尾有可能不匹配。但是如果当前位按照不与p中“字符+*”匹配(也即直接跳过p中'x*')走到最后却有可能成功。 所以，这就需要回溯考虑。如果按照既定步骤匹配到结尾不成功，我们可以回溯回来，然后从当前位用下一个策略去尝试一下。 所有的尝试里，只要成功一次，就算匹配成功！
说到回溯，程序猿的直觉告诉我，需要用递归Recursion!
【解法一：递归 Recursion】
回溯递归解法需要知道3个关键点：（1）如何确定当前步在哪里？（2）当前步有哪些决策？(3) 当前决策失败后回到哪里？
首先，如何确定当前步？由于已经考虑清楚要用递归，那么其实是不需要指针的。递归其实就是把大问题化为小问题的典型解题方案。本题的大问题是s和p是否匹配。假设s当前从左往右的一个子部分s1已经和p从左往右的一个子部分p1匹配了。那么剩下的子问题就是判断，s从s1后的部分和p从p1后的部分是否匹配的问题，这就把问题从大化小了。看下面图:
对于递归方法，由于传参要求都一样，所以显然，传进一个当前串的子串拷贝不就可以了么？
其次，当前有哪些决策，我们来分析一下，由于每次考虑的都是尚未进行匹配测试的子串，所以当前位置就是0位置：
(1) 当前p中下一个字符不为'*'的情况，这种情况下，p当前必须是'.'或者和s当前相同，才能匹配。如果匹配成功，那么s和p各自截取后一位子串继续递归。如果匹配不成功直接返回false。这是策略1;
(2) 当前p中下一个字符为'*'的情况，比较复杂，设当前字符为X。
(2.1) 首先初始假设，p当前的X*在s中根本没有出现过，所以，尝试一下把p后推2位，递归尝试一次。如果失败，说明s当前字符必须和p当前X匹配，然后才有可能成功。
(2.2) 2.1失败，只有X与s当前字符相同做匹配尝试有可能能成功。根据这个策略，s前移一位，p不动，递归尝试一次。如果返回失败，则可以认为必然失败。因为每个情况下，要么X*在s中匹配0次，也即策略1。 要么匹配1或无数次，这是策略2.2。 策略2.1已经失败，策略2.2也失败，没有其他策略可以选择了。所以肯定失败；
第三，怎么回溯？
首先，对于情况(1)，s和p当前必须匹配，并且各推一位尝试成功，才能算成功，两个条件失败一个就肯定失败，所以不存在决策和回溯。
而对于情况（2），由于决策2.1和决策2.2成功一个即可，所以使用一个if-else判断。如果决策2.1成功，直接成功。 如果2.1失败，进入决策2.2 看看是否成功。
此外，递归方案必须考虑基准条件。什么是基准条件。s和p当前都是空串，肯定匹配，返回成功。p当前只有一个字符（因为上面每次都要考虑p下一个字符的问题，所以只有一个字符的时候是个特殊情况，需要单独拎出来考虑），这个时候，p当前字符必须和s当前字符匹配，并且s不能为空，才能算成功。
好了，到了这里，全部分析完了，可以编码。
【Show me the Code!!!】
1 /** 2 * 递归方法: 3 * 每次检查当前字符,有几种可能性: 4 * 1. p的下一个字符是*,那么首先考虑的可能性是S当前字符并不是p当前字符的通配出现, 也即初始假设p当前这个字符并没有在s中出现. 5 * 1.1 初始尝试,p指针后移2位递归求个结果,如果true,那肯定直接返回成功 6 * 1.2 初始尝试失败, 说明s当前字符需要和p当前字符匹配一下, 再递归一次, 看看结果. 如果还不行,那直接返回失败. 7 * 2. p的下一个字符不是*, 那么有2个可能性: p当前是. 或者 普通字符. 8 * 这两种情况下,都需要考虑和s当前字符的匹配情况,成功则指针后移,不成功则直接返回false 9 * @param s 待匹配串 10 * @param p 正则表达式 11 * @return 是否匹配的结果 12 */ 13 public static boolean isMatch(String s, String p) { 14 if(p.length() == 0) return s.length() == 0; 15 16 if(p.length() == 1) { 17 //这个返回的精妙之处在于,直接把对s的长度条件融入到了与条件里. 这个条件成立的时候,后面的条件才能拿来做最终的判断. 18 //如果s的长度条件不满足,那么后面不用判断了,肯定是false的. 19 //所以用了"&&",相当于以下2句的效果: 20 // if(s.length()==1) return p.charAt(0) == '.' || p.charAt(0) == s.charAt(0); 21 // else return false; 22 return s.length() == 1 && (p.charAt(0) == '.' || p.charAt(0) == s.charAt(0)); 23 } 24 25 //p.length()>1时, 看当前字符的下一个字符是什么了. 26 if(p.charAt(1) == '*') { 27 if(isMatch(s, p.substring(2))) return true;//初始假设 28 else { // 初始假设失败, s当前字符必须和p当前字符匹配,才有可能成功 29 // s.length() > 0 的意义上面讲过: 30 // 如果s已经为空串了,又已知p除去当前2个通配字符以后还有字符和s不匹配, 那就不用比了, 现在肯定也不匹配. 31 // 第二行的意义是, p当前还得是'.' 或者和s相同的字符 32 // 第三行的意义是, s跳过当前字符后,和p匹配了 33 // 以上三个条件都成立, 才能算最终可以匹配成功. 34 // 否则均失败 35 return s.length() > 0 36 && (p.charAt(0) == '.' || p.charAt(0) == s.charAt(0)) 37 && isMatch(s.substring(1), p); 38 } 39 } 40 41 //p当前字符下一个字符不是*, 最好处理 42 //匹配的条件是, 43 //1.s不为空串,因为s若为空串, 而p当前字符不是.就是普通字符,必须有个字符和它匹配,那必然失败 44 //2.p当前和s当前匹配 45 //3.p和s分别后移一位,也最终匹配 46 //1+2+3返回成功,才能算成功 47 else { 48 return s.length() > 0 49 && (p.charAt(0) == '.' || p.charAt(0) == s.charAt(0)) 50 && isMatch(s.substring(1), p.substring(1)); 51 } 52 }
【回溯法的反思】
递归的解法向来都是比较慢的，因为不是尾递归，每次递归栈中需要保存方法中全部变量信息，串长度一大，速度可想而知。还有没有更快的办法？更合理的办法？答案是肯定的。
【解法二：动态规划 DP】
动态规划的核心思想是，把算法执行过程中的中间结果保存起来，为了计算下一个状态，可以根据当前状态的结果递推得出。比如著名的菲波那切数列，1，1，2，3，5，8，13....，显然为了求当前的数字，只需要知道前面2个数字即可，之前的结果不再重要。但是如果用递归来解，那么之前的每一步的结果，都会保存在栈中，耗时耗空间。
此外，动态规划还适合解决只需要知道结果，而不关注中间过程的题目。如果，中间过程也需要给出，动态规划可能就不太适合了。
好了，既然是从前一个状态推当前状态，那么我们需要建立一个递推模型，然后找出递推公式（但凡用DP解题，这个是必须的！）。
【递推模型】
我们用一个二维数组来记录中间状态，并且数组元素就是boolean变量。比如dp[i][j]表示s中s{0,1,...i-1}子串和p中p{0,1,....j-1}子串的匹配情况。然后我们可以根据dp[i-1][j-1]的真假以及s{i-1}和p{j-1}的匹配情况，综合判断得出dp[i][j]的结果。
【递推公式】
既然我们用了2维数组，并且在递推的过程中要经常检查dp[i-1][j-1]这些情况，所以为防止越界，我们需要考虑先把数组的第一行和第一列先确定下来。
首先，显然的是，s为空串，p也为空串的情况下，dp[0][0]就表示了这个状态，显然 dp[0][0] = true。
同时，根据上面的递推模型来看，第一行dp[0][j]其实就表示了s为空串的时候，p和空串s匹配的情况。 而dp[i][0]表示，p为空串时，s各个字符和p匹配的情况。显然，dp[i][0]也就是第一列除第一行外肯定全部为false。因为p为空串，s只要不是空串就肯定不匹配。
我们来看看dp[0][j]的各个情况：
（1）j为1的时候，dp[0][1]=false。
（2）j>1的时候，p{j-1}=='*'为真并且dp[0][j-2]也为真，dp[0][j]才能为真。
这样，我们在正式递推之前，把这两个边界情况讨论清楚了。
由于前面已经把i==0和j==0情况下的边界讨论清楚了，所以我们的两个循环i和j都分别从1开始，到字符串最后一个字符停止。所以，用两个for循环可搞定。
为了求dp[i][j]，其实要看p{j-1}的情况：
（1）p{j-1}!='*'情况：简单。p{j-1}必须和s{i-1}字符匹配。同时dp[i-1][j-1]必须匹配成功。这是个&&逻辑。
（2）p{j-1}=='*'情况，参考上面递归方法中的分析，假设p{j-2} = X, 所以目前有个*二元组:X*, 有2个不同的可能性:
(2.1) X在s中根本没有出现，那么dp[i][j] = dp[i][j-2] ;
(2.2) X在s中已经出现了1次或N次。1次的时候，p{j-2} == s{i-1}或者p{j-2}=='.'，同时，dp[i-1][j]要为真，也即当前的p{0,...j-1}已经能匹配s{0,...i-2}，那么前面条件如果成立，p{0....j-1}就也能匹配s{0,...i-1}。这两个条件是&&的关系，都得成立，才能算成功。
显然，2.1和2.2之间是||的关系。
到此，递推公式就出来了。然后按照递推公式去写就行了。最终，根据模型定义，dp[s.length][p.length]就是我们要求的结果: s{0,...slength-1} 与 p{0,...plength-1}的匹配情况。
【Show me the Code!!!】
1 /** 2 * 根据自己的理解写的DP, O(nm)时间, 但是空间是O(MN).时间应该是不能再优化了, 空间可优化成上面的O(slength) 3 * @param s 4 * @param p 5 * @return 6 */ 7 public static boolean isMatchDP(String s, String p) { 8 int slen = s.length(); 9 int plen = p.length(); 10 11 /** 12 * 保存动态规划的中间结果,我们用dp[i][j]来表示: S{0,..i-1} 与P{0,..j-1}的匹配结果. 13 */ 14 boolean dp[][] = new boolean[slen+1][plen+1];//上面解释了,i和j在dp里代表s和p的下标.所以,dp尺寸需要加1 15 16 /** 17 * 下面来分析一下递推公式(DP少不了这个东西!). 18 * 所谓递推公式就是根据之前已经保存的状态推出当前的状态. 也即求当前dp[i][j],可根据之前的结果间接的求出 19 * 假设当前求dp[i][j], 它代表了S{0->i-1}与P{0->j-1}的匹配情况. 那么有以下几个可能: 20 * (1)如果p{j-1}当前不是*,情况简单,当前匹配的唯一条件就是p{j-1}要与s{i-1}匹配 21 * 并且, 之前也都一直匹配, dp[i-1][j-1]匹配! 两者哪个不满足都是false,所以两个条件"&&"一下即可. 22 * 得递推公式: 23 * when p{j-1}!='*', dp[i][j] = dp[i-1][j-1] && p{j-1} == s{i-1} || p{j-1} == '.' 24 * (2)如果p{j-1}当前是个*, 情况比较复杂了. 首先看看有哪几种可能性, 我们设p{j-2} = X, X* 是个二元组 25 * (2.1) X没有在s中重复过, 也即X重复了0次, 所以这种情况就是只要dp[i][j-2]为true, 当前就可以为true. 26 * (2.2) X在S中...i-3,i-2,i-1的位置出现过>=1次, >=1可以拆分开理解,=1成立&&>1也成立!(这是本题最难的部分!一旦理解,这个题就是个easy题了!) 27 * 那么可以假设出现一次的话, 显然必须满足 p{j-2}==s{i-1}||p{j-2}=='.' 28 * 出现>1次, 还应要求, S{0->i-2}最起码要能匹配p{0->j-1}, 也即dp[i-1][j]也需为true 29 * 综上, 2.1和2.2之间是或者的关系,但是2.2内部,>=1我们拆成了>1&&=1的情况,这样就是个&&的关系 30 * 得递推公式: 31 * when p{j-1}=='*', dp[i][j] = dp[i][j-2] || (p{j-2}==s{i-1}||p{j-2}=='.') && dp[i-1][j] 32 * 有了递推公式, 我们可以看到,当i和j分别推进到各自边界的时候,两个串的最终匹配结果一定保存在dp[slen][plen],return这个结果就可以了! 33 */ 34 35 /** 36 * 显然 dp[0][0] = true, 因为代表两个空串做匹配的结果,肯定是true 37 */ 38 dp[0][0] = true; 39 40 /** 41 * 当p为空串的时候,s有字符,显然全部不可能匹配 42 */ 43 for(int i = 1; i <= s.length(); i++) { 44 dp[i][0] = false; 45 } 46 47 /** 48 * 显然, i=0, j从1-plen遍历的各个结果,代表了p各个子串分别是否能否匹配空串s. 49 * 有一定可能, 当p中j-1位置是*,并且0->j-3的匹配结果是true, 也即dp[0][j-2] = true 50 * 否则,dp[0][j] =false 51 * 这里, 我们把i=0的第一行计算出来 52 */ 53 for(int j = 1; j <= p.length(); j++) { 54 //之所以从1开始,是为了方便理解: j位置结果表示了p{0->j-1}的匹配结果 55 //所以,显然dp[0][1]代表了p第一个字符是否能够匹配空串, 显然是不可能的 56 if(j==1) dp[0][j] = false; 57 else dp[0][j] = p.charAt(j-1) == '*' && dp[0][j-2]; 58 } 59 60 61 62 /**到这里,我们就已经分析完了基本边界情况以及空串情况,下来开始递推*/ 63 for(int i = 1; i <= slen; i++) { 64 for(int j = 1; j <= plen; j++) { 65 if(p.charAt(j-1) != '*') { 66 dp[i][j] = dp[i-1][j-1] && (p.charAt(j-1) == '.' || p.charAt(j-1) == s.charAt(i-1)); 67 } 68 else { 69 dp[i][j] = dp[i][j-2]|| 70 (p.charAt(j-2) == '.' || p.charAt(j-2) == s.charAt(i-1)) && dp[i-1][j]; 71 } 72 } 73 } 74 return dp[slen][plen]; 75 }
【DP的反思】
上面这个DP时间复杂度是O(mn), 空间复杂度是O(mn)。 还是有优化余地的。在网上看大神的解法，有一个O(N)空间复杂度的解法很牛逼，这里贴出来，我还没有对单个字符为什么要从后往前匹配研究清楚，慢慢研究吧！
1 /** 2 * This is the O(nm) time and O(n) space DP, awesome! 3 * @param s 4 * @param p 5 * @return 6 */ 7 public static boolean isMatch(String s, String p) { 8 String[] patterns = new String[p.length()]; 9 int i = 0, ptr = 0; 10 while (i != p.length()) {//parse p into tokens[], 要么单字符,要么*二元组 11 if (i + 1 < p.length() && p.charAt(i + 1) == '*') { 12 patterns[ptr++] = p.substring(i, i + 2); 13 i += 2; 14 } 15 else { 16 patterns[ptr++] = p.substring(i, i + 1); 17 i += 1; 18 } 19 } 20 21 boolean[] d = new boolean[s.length() + 1]; 22 d[0] = true; 23 for (i = 1; i <= s.length(); ++i) d[i] = false; //d[]全部置为false 24 for (i = 1; i <= ptr; ++i) { 25 //根据tokens[], 一一判断是否和s中每个字符匹配. 26 String pattern = patterns[i - 1];//获取当前token 27 char c = pattern.charAt(0);//当前token第一个字符 28 if (pattern.length() == 2) {//2元组情况 29 for (int j = 1; j <= s.length(); ++j) {//分别针对s中字符进行匹配测试 30 d[j] = d[j] || (d[j - 1] && (c == '.' || c == s.charAt(j - 1))); 31 } 32 } 33 else {//单个情况 34 for (int j = s.length(); j >= 1; --j) { 35 d[j] = d[j - 1] && (c == '.' || c == s.charAt(j - 1)); 36 } 37 } 38 d[0] = d[0] && pattern.length() == 2; 39 } 40 return d[s.length()]; 41 }
