字符串转换成整数，字符串匹配问题

本文转自csdn大神v_JULY_v的博客

地址：

http://blog.csdn.net/v_july_v/article/details/9024123

阅读心得：自己原先想得太天真了。。。

第三十~三十一章：字符串转换成整数，字符串匹配问题

前言

    之前本一直想写写神经网络算法和EM算法，但写这两个算法实在需要大段大段的时间，而平时上班，周末则跑去北大教室自习看书（顺便以时间为序，说下过去半年看过的自觉还不错的几本书：《数理统计学简史》《微积分概念发展史》《微积分的历程：从牛顿到勒贝格》《数学恩仇录》《数学与知识的探求》《古今数学思想》《素数之恋》），故一直未曾有时间写。

     然最近在负责一款在线编程挑战平台：http://hero.pongo.cn/（简称hero，通俗理解是中国的topcoder，当然，一直在不断完善中，与一般OJ不同点在于，OJ侧重为参与ACM竞赛者提供刷题练习的场所，而hero则着重为企业招聘面试服务），在上面出了几道编程面试题，有些题目看似简单，但一coding，很多问题便立马都在hero上给暴露出来了，故就从hero上的编程挑战题切入，继续更新本程序员编程艺术系列吧。

    况且，前几天与一朋友聊天，他说他认识的今年360招进来的三四十人应届生包括他自己找工作时基本都看过我的博客，则更增加了更新此编程艺术系列的动力。

    OK，本文讲两个问题：

• 第三十章、字符串转换成整数；
• 第三十一章、字符串匹配问题

    还是这句老话，有问题恳请随时批评指正，感谢。

第三十章、字符串转换成整数

    先看题目：

输入一个表示整数的字符串，把该字符串转换成整数并输出，例如输入字符串"345"，则输出整数345。
请完成函数StrToInt，实现字符串转换成整数的功能，不得用库函数atoi。

    我们来一步一步分析，直至写出第一份准确的代码：

1、本题考查的实际上就是字符串转换成整数的问题，或者说是要你自行实现atoi函数。那如何实现把表示整数的字符串正确地转换成整数呢？以"345"作为例子：

1. 当我们扫描到字符串的第一个字符'3'时，由于我们知道这是第一位，所以得到数字3。
2. 当扫描到第二个数字'4'时，而之前我们知道前面有一个3，所以便在后面加上一个数字4，那前面的3相当于30，因此得到数字：3*10+4=34。
3. 继续扫描到字符'5'，'5'的前面已经有了34，由于前面的34相当于340，加上后面扫描到的5，最终得到的数是：34*10+5=345。

    因此，此题的思路便是：每扫描到一个字符，我们便把在之前得到的数字乘以10，然后再加上当前字符表示的数字。

    2、思路有了，有一些细节需要注意，如zhedahht所说：

1. “由于整数可能不仅仅之含有数字，还有可能以'+'或者'-'开头，表示整数的正负。因此我们需要把这个字符串的第一个字符做特殊处理。如果第一个字符是'+'号，则不需要做任何操作；如果第一个字符是'-'号，则表明这个整数是个负数，在最后的时候我们要把得到的数值变成负数。
2. 接着我们试着处理非法输入。由于输入的是指针，在使用指针之前，我们要做的第一件是判断这个指针是不是为空。如果试着去访问空指针，将不可避免地导致程序崩溃。
3. 另外，输入的字符串中可能含有不是数字的字符。每当碰到这些非法的字符，我们就没有必要再继续转换。
4. 最后一个需要考虑的问题是溢出问题。由于输入的数字是以字符串的形式输入，因此有可能输入一个很大的数字转换之后会超过能够表示的最大的整数而溢出。”

    比如，当给的字符串是如左边图片所示的时候，有考虑到么？当然，它们各自对应的正确输出如右边图片所示（ 假定你是在32位系统下，且编译环境是VS2008以上）：

    3、很快，可能你就会写下如下代码：

1. //copyright@zhedahht 2007    
2. enum Status {kValid = 0, kInvalid};  
3. int g_nStatus = kValid;  
4.   
5. // Convert a string into an integer  
6. int StrToInt(const char* str)  
7. {  
8.     g_nStatus = kInvalid;  
9.     long long num = 0;  
10.   
11.     if(str != NULL)  
12.     {  
13.         const char* digit = str;  
14.   
15.         // the first char in the string maybe '+' or '-'  
16.         bool minus = false;  
17.         if(*digit == '+')  
18.             digit ++;  
19.         else if(*digit == '-')  
20.         {  
21.             digit ++;  
22.             minus = true;  
23.         }  
24.   
25.         // the remaining chars in the string  
26.         while(*digit != '\0')  
27.         {  
28.             if(*digit >= '0' && *digit <= '9')  
29.             {  
30.                 num = num * 10 + (*digit - '0');  
31.   
32.                 // overflow    
33.                 if(num > std::numeric_limits<int>::max())  
34.                 {  
35.                     num = 0;  
36.                     break;  
37.                 }  
38.   
39.                 digit ++;  
40.             }  
41.             // if the char is not a digit, invalid input  
42.             else  
43.             {  
44.                 num = 0;  
45.                 break;  
46.             }  
47.         }  
48.   
49.         if(*digit == '\0')  
50.         {  
51.             g_nStatus = kValid;  
52.             if(minus)  
53.                 num = 0 - num;  
54.         }  
55.     }  
56.     return static_cast<int>(num);  
57. }  

    run下上述程序，会发现当输入字符串是下图中红叉叉部分所对应的时候，程序结果出错：  

    

    两个问题：

1. 当输入的字符串不是数字，而是字符的时候，比如“1a”，上述程序直接返回了0（而正确的结果应该是得到1）：
   1. // if the char is not a digit, invalid input  
   2.                   else  
   3.                   {  
   4.                       num = 0;  
   5.                       break;  
   6.                   }  
2. 处理溢出时，有问题。

    4、把代码做下微调，如下：

1. //copyright@SP_daiyq 2013/5/29  
2. int StrToInt(const char* str)  
3. {  
4.     int res = 0; // result  
5.     int i = 0; // index of str  
6.     int signal = '+'; // signal '+' or '-'  
7.     int cur; // current digit  
8.   
9.     if (!str)  
10.         return 0;  
11.   
12.     // skip backspace  
13.     while (isspace(str[i]))  
14.         i++;  
15.   
16.     // skip signal  
17.     if (str[i] == '+' || str[i] == '-')  
18.     {  
19.         signal = str[i];  
20.         i++;  
21.     }  
22.   
23.     // get result  
24.     while (str[i] >= '0' && str[i] <= '9')  
25.     {  
26.         cur = str[i] - '0';  
27.   
28.         // judge overlap or not  
29.         if ( (signal == '+') && (cur > INT_MAX - res*10) )  
30.         {  
31.             res = INT_MAX;  
32.             break;  
33.         }  
34.         else if ( (signal == '-') && (cur -1 > INT_MAX - res*10) )  
35.         {  
36.             res = INT_MIN;  
37.             break;  
38.         }  
39.   
40.         res = res * 10 + cur;  
41.         i++;  
42.     }  
43.   
44.     return (signal == '-') ? -res : res;  
45. }  

    会发现，上面第4小节所述的第1个问题解决了：

    

    但，即使这样，上述代码也还是有问题的。当给定下述测试数据的时候，问题就来了：

需要转换的字符串                         代码运行结果         理应得到的正确结果

"    10522545459" 1932610867 2147483647

"         +10523538441s" 1933603849 2147483647

"   +10432359437" 1842424845 2147483647

    什么问题呢？比如说用上述代码转换这个字符串："    10522545459"，它本应得到的正确结果应该是2147483647，但程序实际得到的结果却是：1932610867。故很明显，程序没有很好的解决上面的第2个小问题：溢出问题。

    5、上面说给的程序没有“很好的解决溢出问题。由于输入的数字是以字符串的形式输入，因此有可能输入一个很大的数字转换之后会超过能够表示的最大的整数而溢出。”那么，到底代码该如何写呢？

1. //copyright@淹死鲨鱼ronkins 2013/5/29  
2. //挑战题目：http://hero.pongo.cn/Question/Details?ID=47&ExamID=45  
3. int atoi(const char* str)    
4. {    
5.     long long res = 0;    
6.     int sign = 1;    
7.   
8.     while(isspace(*str))++str;    
9.     if('+' == *str){    
10.         ++str;    
11.     }else if('-' == *str){    
12.         sign = -1;    
13.         ++str;    
14.     }    
15.   
16.     for(; isdigit(*str); ++str){    
17.         res *= 10;    
18.         if(sign > 0)    
19.             res += (*str - '0');    
20.         else    
21.             res -= (*str - '0');    
22.         if(res >= INT_MAX)return INT_MAX;    
23.         else if(res <= INT_MIN)return INT_MIN;    
24.     }    
25.   
26.     return res;    
27. }    

    上面的代码看似能处理数据溢出的问题，其实它只是做了个取巧，即把返回的值res定义成了long long，如下所示：

1. long long res = 0;    

    故严格说来，我们依然未写出准确的规范代码。

    6、那到底该如何解决这个数据溢出的问题呢？库函数atoi的规定超过int值，按最大值maxint：2147483647来，超过-int按最小值minint：-2147483648来。咱们先来看看Microsoft是如何实现atoi的吧：

1. //atol函数  
2. //Copyright (c) 1989-1997, Microsoft Corporation. All rights reserved.  
3. long __cdecl atol(  
4.     const char *nptr  
5.     )  
6. {  
7.     int c; /* current char */  
8.     long total; /* current total */  
9.     int sign; /* if ''-'', then negative, otherwise positive */  
10.   
11.     /* skip whitespace */  
12.     while ( isspace((int)(unsigned char)*nptr) )  
13.         ++nptr;  
14.   
15.     c = (int)(unsigned char)*nptr++;  
16.     sign = c; /* save sign indication */  
17.     if (c == ''-'' || c == ''+'')  
18.         c = (int)(unsigned char)*nptr++; /* skip sign */  
19.   
20.     total = 0;  
21.   
22.     while (isdigit(c)) {  
23.         total = 10 * total + (c - ''0''); /* accumulate digit */  
24.         c = (int)(unsigned char)*nptr++; /* get next char */  
25.     }  
26.   
27.     if (sign == ''-'')  
28.         return -total;  
29.     else  
30.         return total; /* return result, negated if necessary */  
31. }  

    其中，isspace和isdigit函数的实现代码为：

1. isspace(int x)    
2. {    
3.     if(x==' '||x=='/t'||x=='/n'||x=='/f'||x=='/b'||x=='/r')    
4.         return 1;    
5.     else     
6.         return 0;    
7. }    
8.   
9. isdigit(int x)    
10. {    
11.     if(x<='9'&&x>='0')             
12.         return 1;     
13.     else     
14.         return 0;    
15. }   

    然后 atoi调用上面的atol函数，如下所示：

1. //atoi调用上述的atol  
2. int __cdecl atoi(  
3.     const char *nptr  
4.     )  
5. {  
6.     //Overflow is not detected. Because of this, we can just use  
7.     return (int)atol(nptr);  
8. }  

    但很遗憾的是，上述atoi标准代码依然返回的是long：

1. long total; /* current total */  
2. if (sign == ''-'')  
3.     return -total;  
4. else  
5.     return total; /* return result, negated if necessary */  

    再者，下面这里定义成long的total与10相乘，即total*10很容易溢出：

1. long total; /* current total */  
2. total = 10 * total + (c - ''0''); /* accumulate digit */  

   

      7、继续寻找。接下来，咱们来看看 linux内核中是如何实现此字符串转换为整数的问题的。

linux内核中提供了以下几个函数：

1. simple_strtol，把一个字符串转换为一个有符号长整数；
2. simple_strtoll，把一个字符串转换为一个有符号长长整数；
3. simple_strtoul，把一个字符串转换为一个无符号长整数；
4. simple_strtoull，把一个字符串转换为一个无符号长长整数
   

    相关源码及分析如下。

    首先，atoi调下面的strtol：

1. //linux/lib/vsprintf.c  
2. //Copyright (C) 1991, 1992  Linus Torvalds  
3. //simple_strtol - convert a string to a signed long  
4. long simple_strtol(const char *cp, char **endp, unsigned int base)  
5. {  
6.     if (*cp == '-')  
7.         return -simple_strtoul(cp + 1, endp, base);  
8.   
9.     return simple_strtoul(cp, endp, base);  
10. }  
11. EXPORT_SYMBOL(simple_strtol);  

    然后，上面的strtol调下面的strtoul：

1. //simple_strtoul - convert a string to an unsigned long  
2. unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)  
3. {  
4.     return simple_strtoull(cp, endp, base);  
5. }  
6. EXPORT_SYMBOL(simple_strtoul);  

    接着，上面的strtoul调下面的strtoull：

1. //simple_strtoll - convert a string to a signed long long  
2. long long simple_strtoll(const char *cp, char **endp, unsigned int base)  
3. {  
4.     if (*cp == '-')  
5.         return -simple_strtoull(cp + 1, endp, base);  
6.   
7.     return simple_strtoull(cp, endp, base);  
8. }  
9. EXPORT_SYMBOL(simple_strtoll);  

    最后，strtoull调_parse_integer_fixup_radix和_parse_integer来处理相关逻辑：

1. //simple_strtoull - convert a string to an unsigned long long  
2. unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)  
3. {  
4.     unsigned long long result;  
5.     unsigned int rv;  
6.   
7.     cp = _parse_integer_fixup_radix(cp, &base);  
8.     rv = _parse_integer(cp, base, &result);  
9.     /* FIXME */  
10.     cp += (rv & ~KSTRTOX_OVERFLOW);  
11.   
12.     if (endp)  
13.         *endp = (char *)cp;  
14.   
15.     return result;  
16. }  
17. EXPORT_SYMBOL(simple_strtoull);  

    重头戏来了。接下来，我们来看上面strtoull函数中的parse_integer_fixup_radix和_parse_integer两段代码。如鲨鱼所说

• “真正的处理逻辑主要是在_parse_integer里面，关于溢出的处理，_parse_integer处理的很优美，
• 而_parse_integer_fixup_radix是用来自动根据字符串判断进制的”。

    先来看 _parse_integer函数：

1. //lib/kstrtox.c, line 39    
2. //Convert non-negative integer string representation in explicitly given radix to an integer.    
3. //Return number of characters consumed maybe or-ed with overflow bit.    
4. //If overflow occurs, result integer (incorrect) is still returned.    
5. unsigned int _parse_integer(const char *s, unsigned int base, unsigned long long *p)    
6. {    
7.     unsigned long long res;    
8.     unsigned int rv;    
9.     int overflow;    
10.     
11.     res = 0;    
12.     rv = 0;    
13.     overflow = 0;    
14.     while (*s) {    
15.         unsigned int val;    
16.     
17.         if ('0' <= *s && *s <= '9')    
18.             val = *s - '0';    
19.         else if ('a' <= _tolower(*s) && _tolower(*s) <= 'f')    
20.             val = _tolower(*s) - 'a' + 10;    
21.         else    
22.             break;    
23.     
24.         if (val >= base)    
25.             break;    
26.         /*  
27.          * Check for overflow only if we are within range of  
28.          * it in the max base we support (16)  
29.          */    
30.         if (unlikely(res & (~0ull << 60))) {    
31.             if (res > div_u64(ULLONG_MAX - val, base))    
32.                 overflow = 1;    
33.         }    
34.         res = res * base + val;    
35.         rv++;    
36.         s++;    
37.     }    
38.     *p = res;    
39.     if (overflow)    
40.         rv |= KSTRTOX_OVERFLOW;    
41.     return rv;    
42. }  

    解释下两个小细节：

1. 上头出现了个unlikely，其实unlikely和likely经常出现在linux相关内核源码中
   1. if(likely(value)){  
   2.     //等价于if(likely(value)) == if(value)  
   3. }  
   4. else{  
   5. }  
   likely表示value为真的可能性更大，而unlikely表示value为假的可能性更大，这两个宏被定义成：
   1. //include/linux/compiler.h  
   2. # ifndef likely  
   3. #  define likely(x) (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 1))  
   4. # endif  
   5. # ifndef unlikely  
   6. #  define unlikely(x)   (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 0))  
   7. # endif  
2. 呈现下div_u64的代码：
   1. //include/linux/math64.h  
   2. //div_u64  
   3. static inline u64 div_u64(u64 dividend, u32 divisor)  
   4. {  
   5.     u32 remainder;  
   6.     return div_u64_rem(dividend, divisor, &remainder);  
   7. }  
   8.   
   9. //div_u64_rem  
   10. static inline u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)  
   11. {  
   12.     *remainder = dividend % divisor;  
   13.     return dividend / divisor;  
   14. }  

    最后看下_parse_integer_fixup_radix函数：

1. //lib/kstrtox.c, line 23  
2. const char *_parse_integer_fixup_radix(const char *s, unsigned int *base)  
3. {  
4.     if (*base == 0) {  
5.         if (s[0] == '0') {  
6.             if (_tolower(s[1]) == 'x' && isxdigit(s[2]))  
7.                 *base = 16;  
8.             else  
9.                 *base = 8;  
10.         } else  
11.             *base = 10;  
12.     }  
13.     if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')  
14.         s += 2;  
15.     return s;  
16. }  

    OK，至此，字符串转换成整数的问题算是已经解决。如果面试官继续问你，如何把整数转换成字符串呢？请读者思考，同时也欢迎于本文评论下或hero上 show your code。

第三十一章、字符串匹配问题

字符串匹配问题，给定一串字符串，按照指定规则对其进行匹配，并将匹配的结果保存至output数组中，多个匹配项用空格间隔，最后一个不需要空格。

要求：

1. 匹配规则中包含通配符？和*，其中？表示匹配任意一个字符，*表示匹配任意多个（>=0）字符。
2. 匹配规则要求匹配最大的字符子串，例如a*d,匹配abbdd而非abbd,即最大匹配子串。
3. 匹配后的输入串不再进行匹配，从当前匹配后的字符串重新匹配其他字符串。

请实现函数：char* my_find(char  input[],   char rule[])

举例说明

input:abcadefg
rule:a?c
output:abc

input :newsadfanewfdadsf
rule: new
output: new new

input :breakfastfood
rule: f*d
output:fastfood

注意事项：

1. 自行实现函数my_find，勿在my_find函数里夹杂输出，且不准用C、C++库，和Java的String对象；
2. 请注意代码的时间，空间复杂度，及可读性，简洁性；
3. input=aaa，rule=aa时，返回一个结果aa，即可。

    1、本题与上述第三十章的题不同，上题字符串转换成整数更多考察对思维的全面性和对细节的处理，本题则更多的是编程技巧。闲不多说，直接上代码：

1. //copyright@cao_peng 2013/4/23  
2. int str_len(char *a) {  //字符串长度  
3.     if (a == 0) {  
4.         return 0;  
5.     }  
6.     char *t = a;  
7.     for (;*t;++t)  
8.         ;  
9.     return (int) (t - a);  
10. }  
11.   
12. void str_copy(char *a,const char *b,int len) {  //拷贝字符串 a = b  
13.     for (;len > 0; --len, ++b,++a) {  
14.         *a = *b;  
15.     }  
16.     *a = 0;  
17. }  
18.   
19. char *str_join(char *a,const char *b,int lenb) { //连接字符串 第一个字符串被回收  
20.     char *t;  
21.     if (a == 0) {  
22.         t = (char *) malloc(sizeof(char) * (lenb + 1));   
23.         str_copy(t, b, lenb);  
24.         return t;  
25.     }  
26.     else {  
27.         int lena = str_len(a);  
28.         t = (char *) malloc(sizeof(char) * (lena + lenb + 2));  
29.         str_copy(t, a, lena);  
30.         *(t + lena) = ' ';  
31.         str_copy(t + lena + 1, b, lenb);  
32.         free(a);  
33.         return t;  
34.     }  
35. }  
36.   
37. int canMatch(char *input, char *rule) { // 返回最长匹配长度 -1表示不匹配　  
38.     if (*rule == 0) { //已经到rule尾端  
39.         return 0;  
40.     }  
41.     int r = -1 ,may;  
42.     if (*rule == '*') {  
43.         r = canMatch(input, rule + 1);  // *匹配0个字符  
44.         if (*input) {  
45.             may = canMatch(input + 1, rule);  // *匹配非0个字符  
46.             if ((may >= 0) && (++may > r)) {  
47.                 r = may;  
48.             }  
49.         }  
50.     }  
51.     if (*input == 0) {  //到尾端  
52.         return r;  
53.     }  
54.     if ((*rule == '?') || (*rule == *input)) {  
55.         may = canMatch(input + 1, rule + 1);  
56.         if ((may >= 0) && (++may > r)) {  
57.             r = may;  
58.         }  
59.     }  
60.     return r;  
61. }  
62.   
63. char * my_find(char  input[],   char rule[]) {  
64.     int len = str_len(input);  
65.     int *match = (int *) malloc(sizeof(int) * len);  //input第i位最多能匹配多少位 匹配不上是-1  
66.     int i,max_pos = - 1;  
67.     char *output = 0;  
68.   
69.     for (i = 0; i < len; ++i) {  
70.         match[i] = canMatch(input + i, rule);  
71.         if ((max_pos < 0) || (match[i] > match[max_pos])) {  
72.             max_pos = i;  
73.         }  
74.     }  
75.     if ((max_pos < 0) || (match[max_pos] <= 0)) {  //不匹配  
76.         output = (char *) malloc(sizeof(char));  
77.         *output = 0;   // \0  
78.         return output;  
79.     }  
80.     for (i = 0; i < len;) {  
81.         if (match[i] == match[max_pos]) { //找到匹配  
82.             output = str_join(output, input + i, match[i]);  
83.             i += match[i];  
84.         }  
85.         else {  
86.             ++i;  
87.         }  
88.     }  
89.     free(match);  
90.     return output;  
91. }  

     2、本题也可以直接写出DP方程，如下代码所示：

1. //copyright@chpeih 2013/4/23  
2. char * my_find(char  input[],   char rule[]) {  
3.     int len = str_len(input);  
4.     int *match = (int *) malloc(sizeof(int) * len);  //input第i位最多能匹配多少位 匹配不上是-1  
5.     int i,max_pos = - 1;  
6.     char *output = 0;  
7.   
8.     for (i = 0; i < len; ++i) {  
9.         match[i] = canMatch(input + i, rule);  
10.         if ((max_pos < 0) || (match[i] > match[max_pos])) {  
11.             max_pos = i;  
12.         }  
13.     }  
14.     if ((max_pos < 0) || (match[max_pos] <= 0)) {  //不匹配  
15.         output = (char *) malloc(sizeof(char));  
16.         *output = 0;   // \0  
17.         return output;  
18.     }  
19.     for (i = 0; i < len;) {  
20.         if (match[i] == match[max_pos]) { //找到匹配  
21.             output = str_join(output, input + i, match[i]);  
22.             i += match[i];  
23.         }  
24.         else {  
25.             ++i;  
26.         }  
27.     }  
28.     free(match);  
29.     return output;  
30. }  
31.   
32.   
33. char* my_find(char  input[],   char rule[])  
34. {  
35.     //write your code here  
36.     int len1,len2;  
37.     for(len1 = 0;input[len1];len1++);  
38.     for(len2 = 0;rule[len2];len2++);  
39.     int MAXN = len1>len2?(len1+1):(len2+1);  
40.     int  **dp;  
41.   
42.     //dp[i][j]表示字符串1和字符串2分别以i j结尾匹配的最大长度  
43.     //记录dp[i][j]是由之前那个节点推算过来  i*MAXN+j  
44.     dp = new int *[len1+1];  
45.     for (int i = 0;i<=len1;i++)  
46.     {  
47.         dp[i] = new int[len2+1];  
48.     }  
49.     dp[0][0] = 0;  
50.   
51.     for(int i = 1;i<=len2;i++)dp[0][i] = -1;  
52.     for(int i = 1;i<=len1;i++)dp[i][0] = 0;  
53.     for (int i = 1;i<=len1;i++)  
54.     {  
55.         for (int j = 1;j<=len2;j++)  
56.         {  
57.             if(rule[j-1]=='*'){  
58.                 dp[i][j] = -1;  
59.                 if (dp[i-1][j-1]!=-1)  
60.                 {  
61.                     dp[i][j] = dp[i-1][j-1]+1;  
62.   
63.                 }  
64.                 if (dp[i-1][j]!=-1 && dp[i][j]<dp[i-1][j]+1)  
65.                 {  
66.                     dp[i][j] = dp[i-1][j]+1;  
67.   
68.                 }  
69.             }else if (rule[j-1]=='?')  
70.             {  
71.                 if(dp[i-1][j-1]!=-1){  
72.                     dp[i][j] = dp[i-1][j-1]+1;  
73.   
74.                 }else dp[i][j] = -1;  
75.             }   
76.             else  
77.             {  
78.                 if(dp[i-1][j-1]!=-1 && input[i-1]==rule[j-1]){  
79.                     dp[i][j] = dp[i-1][j-1]+1;  
80.                 }else dp[i][j] = -1;  
81.             }  
82.         }  
83.     }  
84.   
85.     int m = -1;//记录最大字符串长度  
86.     int *ans = new int[len1];  
87.     int count_ans = 0;//记录答案个数  
88.     char *returnans = new char[len1+1];  
89.     int count = 0;  
90.   
91.     for(int i = 1;i<=len1;i++)  
92.         if (dp[i][len2]>m){  
93.             m = dp[i][len2];  
94.             count_ans = 0;  
95.             ans[count_ans++] = i-m;  
96.         }else if(dp[i][len2]!=-1 &&dp[i][len2]==m){  
97.             ans[count_ans++] = i-m;  
98.         }  
99.         if (count_ans!=0)  
100.         {      
101.             int len = ans[0];  
102.             for (int i = 0;i<m;i++)  
103.             {  
104.                 printf("%c",input[i+ans[0]]);  
105.                 returnans[count++] = input[i+ans[0]];  
106.             }  
107.             for (int j = 1;j<count_ans;j++)  
108.             {  
109.                 printf(" ");  
110.                 returnans[count++] = ' ';  
111.                 len = ans[j];  
112.                 for (int i = 0;i<m;i++)  
113.                 {  
114.                     printf("%c",input[i+ans[j]]);  
115.                     returnans[count++] = input[i+ans[j]];  
116.                 }  
117.             }  
118.             printf("\n");  
119.             returnans[count++] = '\0';  
120.         }  
121.   
122.         return returnans;  
123. }  

     欢迎于本文评论下或hero上 show your code。

参考文献及推荐阅读

1. http://zhedahht.blog.163.com/blog/static/25411174200731139971/；
   
2. http://hero.pongo.cn/，本文大部分代码都取自左边hero上参与答题者提交的代码，欢迎你也去挑战；
   
3. 字符串转换成整数题目完整描述：http://hero.pongo.cn/Question/Details?ID=47&ExamID=45；
4. 字符串匹配问题题目完整描述：http://hero.pongo.cn/Question/Details?ID=28&ExamID=28；
5. linux3.8.4版本下的相关字符串整数转换函数概览：https://git.kernel.org/cgit/linux/kernel/git/stable/linux-stable.git/tree/lib/vsprintf.c?id=refs/tags/v3.9.4；
6. 关于linux中的likely和unlikely：http://blog.21ic.com/user1/5593/archives/2010/68193.html；