LeetCode10：Regular Expression Matching

最新推荐文章于 2018-03-11 10:30:09 发布
最新推荐文章于 2018-03-11 10:30:09 发布
阅读量381 收藏
点赞数
分类专栏： LeetCode 文章标签： 算法 面试题 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gg543012991/article/details/53494755
版权
原题目：

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).
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", "a*") → true
isMatch("aa", ".*") → true
isMatch("ab", ".*") → true
isMatch("aab", "c*a*b") → true
匹配字符串，“.”能够代替所有字符，“*”代表前一个或前多个字符，例如，b*,可以代表0个b，也可以代表bbbb多个b，这便是难点。

算法分析：
算法1：
如果s的第一个字符和p的第一个字符不相等并且p的第一个字符不是'.',直接返回false
情况1：当p的第二个字符不是‘*’，属于简单情况，如果*前面的字符和s的字符不相等并且p的前一个字符不是'.'，则直接返回false。其中，利用substring(1)来截掉第一个字符（substring(index)用来从头开始截掉Index长度的字符串）
//case1:when the second char of p is not '*',easy case.
        if(p.charAt(1) != '*'){
            if(s.length() < 1){
                return false;
            }
            if((p.charAt(0) != s.charAt(0)) &&(p.charAt(0) != '.')){
                return false;
            }
            else{
                return isMatch(s.substring(1),p.substring(1));
            }
        }  
情况2：当p的第二个字符是“*”的时候，复杂情况：
         要分0代表0个前导字符或者1个或多个前导字符的情况。
          //when the '*' stands for 0 preceding element
            if(isMatch(s,p.substring(2))){            //if * its after element could match s,then ,*replace before 0 element
                return true;
            }
            /*when the '*' stands for 1 or more preceding element,
            try every possible number*/
            int i = 0;
            while(i < s.length() && (s.charAt(i) == p.charAt(0) || 
                    p.charAt(0) == '.')){
                if(isMatch(s.substring(i+1),p.substring(2))){
                    return true;
                }
                i++;
            }
算法:2：
利用动态规划。 动态规划基本思想就是把我们计算过的历史信息记录下来，等到要用到的时候就直接使用，不用重新计算。在这个题里面，假设我们维护一个布尔数组res[i][j],代表s的前i个字符和p的前j个字符是否匹配(注意这里res的维度是s.length()+1,p.length()+1)。递推公式跟上面类似，分三种种情况：
(1)p[j+1]不是'*'。情况比较简单，只要判断如果当前s的i和p的j上的字符一样（如果有p在j上的字符是'.',也是相同），并且res[i][j]==true，则res[i+1][j+1]也为true，res[i+1][j+1]=false;
(2)p[j+1]是'*'，但是p[j]!='.'。那么只要以下条件有一个满足即可对res[i+1][j+1]赋值为true：
    1)res[i+1][j]为真（'*'只取前面字符一次）;
    2)res[i+1][j-1]为真（'*'前面字符一次都不取，也就是忽略这两个字符）;
    3)res[i][j+1] && s[i]==s[i-1] && s[i-1]==p[j-1](这种情况是相当于i从0到s.length()扫过来，如果p[j+1]对应的字符是‘*’那就意味着接下来的串就可以依次匹配下来，如果下面的字符一直重复，并且就是‘*’前面的那个字符）。
(3)p[j+1]是'*'，并且p[j]=='.'。因为".*"可以匹配任意字符串，所以在前面的res[i+1][j-1]或者res[i+1][j]中只要有i+1是true，那么剩下的res[i+1][j+1],res[i+2][j+1],...,res[s.length()][j+1]就都是true了。
这道题有个很重要的点，就是实现的时候外层循环应该是p,然后待匹配串s内层循环扫过来。




LeetCode提交源码：
算法1： 
   
   
  1. public boolean isMatch(String s,String p){
  2. 		//base case
  3. 		if(p.length() == 0){
  4. 			return s.length() == 0;
  5. 		}
  6. 		//special case
  7. 		if(p.length() == 1){
  8. 			
  9. 			//if the length of s is 0 return false
  10. 			if(s.length() < 1){
  11. 				return false;
  12. 			}
  13. 			
  14. 		/*	if the first char of s and the first char of p is not the same
  15. 			and the char of p is not '.',return false*/
  16. 			else if((p.charAt(0) != s.charAt(0)) && (p.charAt(0) != '.')){
  17. 				return false;
  18. 			}
  19. 			
  20. 			//otherwise, compare the rest of the stirng of s and p
  21. 			else{
  22. 				return isMatch(s.substring(1),p.substring(1));
  23. 			}
  24. 		}
  25. 		
  26. 		//case1:when the second char of p is not '*',easy case.
  27. 		if(p.charAt(1) != '*'){
  28. 			if(s.length() < 1){
  29. 				return false;
  30. 			}
  31. 			if((p.charAt(0) != s.charAt(0)) &&(p.charAt(0) != '.')){
  32. 				return false;
  33. 			}
  34. 			else{
  35. 				return isMatch(s.substring(1),p.substring(1));
  36. 			}
  37. 		}
  38. 		
  39. 		//case2: when the second char of p is '*',complex case
  40. 		else{
  41. 			//when the '*' stands for 0 preceding element
  42. 			if(isMatch(s,p.substring(2))){			//if * its after element could match s,then ,*replace before 0 element
  43. 				return true;
  44. 			}
  45. 			
  46. 			/*when the '*' stands for 1 or more preceding element,
  47. 			try every possible number*/
  48. 			int i = 0;
  49. 			while(i < s.length() && (s.charAt(i) == p.charAt(0) || 
  50. 					p.charAt(0) == '.')){
  51. 				if(isMatch(s.substring(i+1),p.substring(2))){
  52. 					return true;
  53. 				}
  54. 				i++;
  55. 			}
  56. 			return false;
  57. 		}
  58. 	}
 
算法2： 
   
   
  1. public boolean isMatch(String s,String p){
  2. 		
  3. 		int m = s.length();
  4. 		int n = p.length();
  5. 		
  6. 		if(m == 0 && n == 0)
  7. 			return true;
  8. 		if(n == 0){
  9. 			return false;
  10. 		}
  11. 		boolean dp[][] = new boolean[m+1][n+1];  		//boolean类型数组默认为false;
  12. 			/*for(int k = 0; k < m; k++){
  13. 				for(int q = 0; q < n; q++){
  14. 					System.out.println(dp[k][q]);
  15. 				}
  16. 			}*/
  17. 		
  18. 		dp[0][0] = true;
  19. 		for(int j = 0;j < n; j++){
  20. 			if(p.charAt(j) == '*'){
  21. 				if(j > 0 && dp[0][j-1])
  22. 					dp[0][j+1] = true;
  23. 				if(j < 1)
  24. 					continue;
  25. 			/*	p[j+1]是'*'，但是p[j]!='.'。那么只要以下条件有一个满足即可对res[i+1][j+1]赋值为true： 
  26. 					    1)res[i+1][j]为真（'*'只取前面字符一次）; 
  27. 					    2)res[i+1][j-1]为真（'*'前面字符一次都不取，也就是忽略这两个字符）; 
  28. 					    3)res[i][j+1] && s[i]==s[i-1] && s[i-1]==p[j-1](这种情况是相当于i从0到s.length()扫过来，
  29. 					       如果p[j+1]对应的字符是‘*’那就意味着接下来的串就可以依次匹配下来，
  30. 					       如果下面的字符一直重复，并且就是‘*’前面的那个字符）*/
  31. 				if(p.charAt(j-1) != '.'){
  32. 					for(int i = 0; i < m;i++){
  33. 						if(dp[i+1][j] || j > 0 && dp[i+1][j-1] || 
  34. 								i > 0 && j > 0 && dp[i][j+1] && s.charAt(i) 
  35. 								== s.charAt(i-1)&& s.charAt(i-1) == p.charAt(j-1))
  36. 							dp[i+1][j+1] = true;
  37. 					}
  38. 				}
  39. 				else{
  40. 					int i = 0;
  41. 					while(j > 0 && i < m && !dp[i+1][j-1] && !dp[i+1][j])
  42. 						i++;
  43. 					for(;i < m; i++){
  44. 						dp[i+1][j+1] = true;
  45. 					}
  46. 				}
  47. 					
  48. 			}
  49. 			else{
  50. 				for(int i = 0;i < m;i++){
  51. 					if(s.charAt(i) == p.charAt(j) || p.charAt(j) == '.')
  52. 						dp[i+1][j+1] = dp[i][j];
  53. 				}
  54. 			}
  55. 		}
  56. 		return dp[m][n];
  57. 	}
 

完整运行程序： 

   
   
  1. /**************************************************************      
  2. * Copyright (c) 2016      
  3. * All rights reserved.                   
  4. * 版 本 号：v1.0                   
  5. * 题目描述： Regular Expression Matching
  6. * 			Implement regular expression matching with support for '.' and '*'.
  7. *			'.' Matches any single character.
  8. *			'*' Matches zero or more of the preceding element.
  9. *			The matching should cover the entire input string (not partial).
  10. * 输入描述：请输入第一个字符串：
  11. *			bbbbba
  12. *			请输入第二个字符串：
  13. *			b*a
  14. * 程序输出：算法1：两个字符串是否匹配：false
  15. *			算法2：两个字符串是否匹配：true
  16. *			算法3：两个字符串是否匹配：true
  17. * 问题分析：
  18. * 算法描述：算法1：简单判断，分别考虑多种情况，但算法运行时间较长
  19. * 			算法2：利用动态规划
  20. * 			动态规划基本思想就是把我们计算过的历史信息记录下来，等到要用到的时候就直接使用，不用重新计算。
  21. *			在这个题里面，假设我们维护一个布尔数组res[i][j],代表s的前i个字符和p的前j
  22. *			个字符是否匹配(注意这里res的维度是s.length()+1,p.length()+1)。
  23. * 完成时间：2016-11-23
  24. ***************************************************************/ 
  26. package org.GuoGuoFighting.LeetCode010;
  28. import java.util.Scanner;
  30. /*算法1：错误的算法，无法得到正确结果*/
  31. class SolutionMethod1{
  32. 	public boolean isMatch(String s,String p){
  33. 		if(s == null || p == null){
  34. 			return false;
  35. 		}
  36. 		
  37. 		int slen = s.length();
  38. 		int plen = p.length();
  39. 		int i = slen-1;
  40. 		int j = plen-1;
  41. 		//boolean flag = false;
  42. 		while(i > 0 && j > 0){
  43. 			while(s.charAt(i) == s.charAt(i-1)){
  44. 				i--;
  45. 			}
  46. 			if(s.charAt(i) == p.charAt(j) || p.charAt(j) == '.'){
  47. 				if(i > 0 && j >0){
  48. 					i--;
  49. 					j--;
  50. 					System.out.println("i=" + i + "j=" + j);
  51. 					return isMatch(s.substring(0, i), p.substring(0, j));
  52. 					//return MatchFunction(s,i, p,j);
  53. 				}
  54. 				else if(i == 0 && j == 0){
  55. 					return true;
  56. 				}
  57. 				else if(s.charAt(i) == s.charAt(i-1)){
  58. 					i--;
  59. 				}
  60. 			}
  61. 			else if(p.charAt(j) == '*' ){
  62. 				j--;
  63. 				return isMatch(s.substring(0, i), p.substring(0, j));
  64. 			}
  65. 			else{
  66. 				return false;
  67. 			}
  68. 		}
  69. 		if( i == 0 && j== 0 && s.charAt(i)== p.charAt(j)){
  70. 			return true;
  71. 			
  72. 		}
  73. 		else
  74. 			return false;
  75. 	}
  76. }
  78. class SolutionMethod2{
  79. 	public boolean isMatch(String s,String p){
  80. 		//base case
  81. 		if(p.length() == 0){
  82. 			return s.length() == 0;
  83. 		}
  84. 		//special case
  85. 		if(p.length() == 1){
  86. 			
  87. 			//if the length of s is 0 return false
  88. 			if(s.length() < 1){
  89. 				return false;
  90. 			}
  91. 			
  92. 		/*	if the first char of s and the first char of p is not the same
  93. 			and the char of p is not '.',return false*/
  94. 			else if((p.charAt(0) != s.charAt(0)) && (p.charAt(0) != '.')){
  95. 				return false;
  96. 			}
  97. 			
  98. 			//otherwise, compare the rest of the stirng of s and p
  99. 			else{
  100. 				return isMatch(s.substring(1),p.substring(1));
  101. 			}
  102. 		}
  103. 		
  104. 		//case1:when the second char of p is not '*',easy case.
  105. 		if(p.charAt(1) != '*'){
  106. 			if(s.length() < 1){
  107. 				return false;
  108. 			}
  109. 			if((p.charAt(0) != s.charAt(0)) &&(p.charAt(0) != '.')){
  110. 				return false;
  111. 			}
  112. 			else{
  113. 				return isMatch(s.substring(1),p.substring(1));
  114. 			}
  115. 		}
  116. 		
  117. 		//case2: when the second char of p is '*',complex case
  118. 		else{
  119. 			//when the '*' stands for 0 preceding element
  120. 			if(isMatch(s,p.substring(2))){			//if * its after element could match s,then ,*replace before 0 element
  121. 				return true;
  122. 			}
  123. 			
  124. 			/*when the '*' stands for 1 or more preceding element,
  125. 			try every possible number*/
  126. 			int i = 0;
  127. 			while(i < s.length() && (s.charAt(i) == p.charAt(0) || 
  128. 					p.charAt(0) == '.')){
  129. 				if(isMatch(s.substring(i+1),p.substring(2))){
  130. 					return true;
  131. 				}
  132. 				i++;
  133. 			}
  134. 			return false;
  135. 		}
  136. 	}
  137. }
  139. class SolutionMethod3{
  140. 	public boolean isMatch(String s,String p){
  141. 		
  142. 		int m = s.length();
  143. 		int n = p.length();
  144. 		
  145. 		if(m == 0 && n == 0)
  146. 			return true;
  147. 		if(n == 0){
  148. 			return false;
  149. 		}
  150. 		boolean dp[][] = new boolean[m+1][n+1];  		//boolean类型数组默认为false;
  151. 			/*for(int k = 0; k < m; k++){
  152. 				for(int q = 0; q < n; q++){
  153. 					System.out.println(dp[k][q]);
  154. 				}
  155. 			}*/
  156. 		
  157. 		dp[0][0] = true;
  158. 		for(int j = 0;j < n; j++){
  159. 			if(p.charAt(j) == '*'){
  160. 				if(j > 0 && dp[0][j-1])
  161. 					dp[0][j+1] = true;
  162. 				if(j < 1)
  163. 					continue;
  164. 			/*	p[j+1]是'*'，但是p[j]!='.'。那么只要以下条件有一个满足即可对res[i+1][j+1]赋值为true： 
  165. 					    1)res[i+1][j]为真（'*'只取前面字符一次）; 
  166. 					    2)res[i+1][j-1]为真（'*'前面字符一次都不取，也就是忽略这两个字符）; 
  167. 					    3)res[i][j+1] && s[i]==s[i-1] && s[i-1]==p[j-1](这种情况是相当于i从0到s.length()扫过来，
  168. 					       如果p[j+1]对应的字符是‘*’那就意味着接下来的串就可以依次匹配下来，
  169. 					       如果下面的字符一直重复，并且就是‘*’前面的那个字符）*/
  170. 				if(p.charAt(j-1) != '.'){
  171. 					for(int i = 0; i < m;i++){
  172. 						if(dp[i+1][j] || j > 0 && dp[i+1][j-1] || 
  173. 								i > 0 && j > 0 && dp[i][j+1] && s.charAt(i) 
  174. 								== s.charAt(i-1)&& s.charAt(i-1) == p.charAt(j-1))
  175. 							dp[i+1][j+1] = true;
  176. 					}
  177. 				}
  178. 				else{
  179. 					int i = 0;
  180. 					while(j > 0 && i < m && !dp[i+1][j-1] && !dp[i+1][j])
  181. 						i++;
  182. 					for(;i < m; i++){
  183. 						dp[i+1][j+1] = true;
  184. 					}
  185. 				}
  186. 					
  187. 			}
  188. 			else{
  189. 				for(int i = 0;i < m;i++){
  190. 					if(s.charAt(i) == p.charAt(j) || p.charAt(j) == '.')
  191. 						dp[i+1][j+1] = dp[i][j];
  192. 				}
  193. 			}
  194. 		}
  195. 		return dp[m][n];
  196. 	}
  197. }
  199. public class RegularExpressionMatching {
  200. 	public static void main(String[] args){
  201. 		Scanner scanner = new Scanner(System.in);
  202. 		System.out.println("请输入第一个字符串：");
  203. 		String s = scanner.nextLine();
  204. 		System.out.println("请输入第二个字符串：");
  205. 		String p = scanner.nextLine();
  206. 		scanner.close();
  207. 		
  208. 		SolutionMethod1 solution1 = new SolutionMethod1();
  209. 		System.out.println("算法1：两个字符串是否匹配：" + solution1.isMatch(s, p));
  210. 		
  211. 		SolutionMethod2 solution2 = new SolutionMethod2();
  212. 		System.out.println("算法2：两个字符串是否匹配：" + solution2.isMatch(s, p));
  213. 		
  214. 		SolutionMethod3 solution3 = new SolutionMethod3();
  215. 		System.out.println("算法3：两个字符串是否匹配："+ solution3.isMatch(s, p));
  216. 	}
  217. }


程序运行结果：
 

安心写代码吧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode 第10题 Regular Expression Matching
paofuhemakalong的博客
05-16 825
周末也没有做leetcode，感觉有点罪恶啊，这个第10题好难啊，涉及到递归了，看的我是头晕眼花啊。我看着看着还是有点收获的，我发现题目仍然没有我想象中的那么的简单，如果s = 'a b c d e'，p = '. * e'，这样匹配出的结果也是正确的，我就很纳闷儿啊，' . '是匹配任意一个字符，可是我以为只能匹配一个字符，但是从这个算例上看，当它和' * '在一起时，' . '可以多次匹配不同
个人记录-LeetCode 10.Regular Expression Matching
ZhangJian的博客
10-15 773
LeetCode 10
leetcode10:Regular Expression Matching
刘伟的博客
03-11 277
1.题目如下： '.' Matches any single character. '*' Matches zero or more of the preceding element. The matching should cover the entire input string (not partial). The function prototype should be: boo...
Leetcode 10: Regular Expression Matching
丫丫狸笫的专栏
08-16 308
Leetcode 10: Regular Expression MatchingImplement regular expression matching with support for ‘.’ and ‘*’. ‘.’ Matches any single character. ‘*’ Matches zero or more of the preceding element.
leetcode 10: Regular Expression Matching
西施豆腐渣
05-01 2713
Regular Expression Matching Total Accepted: 39732 Total Submissions: 192279 Implement regular expression matching with support for '.' and '*'. '.' Matches any single character. '*' Mat
leetcode中国-leetcode:leetcode刷题
06-29
Expression Matching 递归匹配 wildcard matching 动态规划 longest common prefix , 简单 valid number, hard, 用有限自动机 integer to roman ,easy , 模拟 roman to integer ,easy , 模拟 count and say , easy ,...
leetcode答案-leetcode:leetcode
06-30
leetcode 答案 leet code 这是我的leetcode答案，语言主要是用python。很多算法不是最优，甚至很槽糕，有空就会优化 目前完成了: Two Sum Add Two Numbers Longest ...Regular Expression Matching
leetcode分类-leetcode:leetcode刷题
06-30
4. **正则表达式匹配**：“实现一个简单的正则表达式匹配器”（Regular Expression Matching），涉及到递归和动态规划。 5. **字符串编码与解码**：“无重复字符的最长子串”（Longest Substring Without Repeating...
leetcode338-LeetCode:LeetCode刷题总结
07-01
10.Regular Expression Matching 11.Container With Most Water 12.Integer to Roman 13.Roman to Integer 14.Longest Common Prefix (Trie树待完成) 15.3Sum 16.3Sum Closest 17.Letter Combinations of a Phone ...
leetcode写题闪退-LeetCode:leetcodeOJ
06-30
leetcode写题闪退 #*的多少代表此题的有意思程度 有几题第一次写的时候思绪比较混乱： *****Regular Expression Matching 2014.10.29 对于Find Minimum in Rotated Sorted Array II 和 Find Minimum in Rotated ...
LeetCode02:Add Two Numbers Java实现
做一名努力的通信程序员
11-16 1114
原题目： You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it a
LeetCode014:Longest Common Prefix
做一名努力的通信程序员
12-06 544
原题目： Write a function to find the longest common prefix string amongst an array of strings. 找到一个字符串数组中，最长的公共前缀子串，并输出。 算法分析： 算法1：各种错误，各种提交不通过，各种特殊情况没考虑，服了！ 算法2： 纵向
LeetCode08：String to Integer(atoi)
做一名努力的通信程序员
12-06 518
原题目： Implement atoi to convert a string to an integer. 实现atoi函数，即将字符串转化为整数 算法分析： 函数首先丢弃所需的空格字符，直到找到第一个非空格字符。然后，从该字符开始，采用可选的初始加号或减号，后跟尽可能多的数字，并将其解释为数值。 字符串可以包含在形成整数数字之后的附加字符，这些字符
LeetCode06：ZigZag Conversion
做一名努力的通信程序员
11-16 516
原题目： The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility) P      A       H
LeetCode11： Container With Most Water
做一名努力的通信程序员
12-06 505
原题目： Given n non-negative integers a1, a2, ..., an, where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). F
LeetCode013：Roman to Integer
做一名努力的通信程序员
12-06 501
原题目： Given a roman numeral, convert it to an integer. Input is guaranteed to be within the range from 1 to 3999. 将罗马数字转换成阿拉伯数字 算法分析： 算法1： 从前往后扫描，用一个临时变量记录分段数字。如果当前比前一个大，说
LeetCode07：Reverse Integer
做一名努力的通信程序员
11-16 489
原题目： Reverse digits of an integer. Example1: x = 123, return 321 Example2: x = -123, return -321 翻转输入的整数 算法分析： 算法1： 将整数转化为字符串，通过翻转字符串来实现数字的翻转。 算法2： 将整数放入字符数组中，通过从尾到头
LeetCode12：Integer to Roman
做一名努力的通信程序员
12-06 446
原题目： Given an integer, convert it to a roman numeral. Input is guaranteed to be within the range from 1 to 3999. 给定一个数字，将其转换成为罗马数字输出 算法分析： 罗马数字构成： 罗马数字共有7个，即Ⅰ（1）、Ⅴ（5）、Ⅹ（10）、Ⅼ（50）、Ⅽ（100
LeetCode05:Longest Palindromic Substring
做一名努力的通信程序员
11-16 432
原题目： Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000. Example: Input: "babad" Output: "bab" Note: "aba" is also a valid an
LeetCode题解：算法刷题攻略
LeetCode是一个知名的在线平台，专注于算法训练和问题解决，帮助程序员提升编程技能，特别是算法和数据结构方面的知识。这个资源是关于在LeetCode上刷题的一个集合，由用户"soulmachine@gmail.com"分享，提供了C++11...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值