关闭

程序员编程艺术:第二章、字符串是否包含问题

329人阅读 评论(0) 收藏 举报
分类:

文章转载:http://blog.csdn.net/v_july_v/article/details/6347454 

程序员编程艺术:第二章、字符串是否包含问题


作者:July,yansha,caopengcs。
时间:二零一一年四月二十三日。
致谢:老梦,nossiac,Hession,Oliver,luuillu,啊菜,雨翔,及微软100题实现小组所有成员。


题目描述:
假设这有一个各种字母组成的字符串A,和另外一个字符串B,字符串里B的字母数相对少一些。什么方法能最快的查出所有小字符串B里的字母在大字符串A里都有?

比如,如果是下面两个字符串:
String 1: ABCDEFGHLMNOPQRS
String 2: DCGSRQPO
答案是true,所有在string2里的字母string1也都有。
  
如果是下面两个字符串:  
String 1: ABCDEFGHLMNOPQRS   
String 2: DCGSRQPZ  
答案是false,因为第二个字符串里的Z字母不在第一个字符串里。

    点评:
    1、题目描述虽长,但题意简单明了,就是给定一长一短的俩个字符串A,B,假设A长B短,现在,要你判断B是否包含在字符串A中,即B?(-A。

    2、题意虽简单,但实现起来并不轻松,且当如果面试官步步紧逼,一个一个否决你能想到的方法,要你给出更好、最好的方案时,你恐怕就要伤不少脑筋了。

    ok,在继续往下阅读之前,您最好先想个几分钟,看你能想到的最好方案是什么,是否与本文最后实现的方法一致。


1.1、O(n*m)的轮询方法

判断string2中的字符是否在string1中?:
String 1: ABCDEFGHLMNOPQRS
String 2: DCGSRQPO

    判断一个字符串是否在另一个字符串中,最直观也是最简单的思路是,针对第二个字符串string2中每一个字符,一一与第一个字符串string1中每个字符依次轮询比较,看它是否在第一个字符串string1中。

    代码可如下编写:

  1. //copyright@啊菜 2011  
  2. //updated@July&Image丶时光 2013  
  3. #include <iostream>    
  4. #include <string>  
  5. using namespace std;    
  6.   
  7. int CompareString(string LongString,string ShortString)    
  8. {    
  9.     int i,j;  
  10.     for (i=0; i<ShortString.length(); i++)    
  11.     {    
  12.         for (j=0; j<LongString.length(); j++)  //O(n*m)    
  13.         {    
  14.             if (LongString[j] == ShortString[i])  //一一比较    
  15.             {    
  16.                 break;    
  17.             }    
  18.   
  19.         }    
  20.         if (j==LongString.length())    
  21.         {    
  22.             cout << "false" << endl;    
  23.             return 0;    
  24.         }    
  25.     }    
  26.     cout << "true" << endl;    
  27.     return 1;    
  28. }    
  29.   
  30. int main()     
  31. {     
  32.     string LongString="ABCDEFGHLMNOPQRS";    
  33.     string ShortString="DCGSRQPO";    
  34.     CompareString(LongString,ShortString);    
  35.     return 0;    
  36. }      

    假设n是字符串string1的长度,m是字符串string2的长度,那么此算法,需要O(n*m)次操作,拿上面的例子来说,最坏的情况下将会有16*8 = 128次操作。显然,时间开销太大,我们需要找到一种更好的办法。

 

1.2、O(mlogm)+O(nlogn)+O(m+n)的排序方法
    一个稍微好一点的方案是先对这两个字符串的字母进行排序,然后同时对两个字串依次轮询。两个字串的排序需要(常规情况)O(m log m) + O(n log n)次操作,之后的线性扫描需要O(m+n)次操作

    同样拿上面的字串做例子,将会需要16*4 + 8*3 = 88,再加上对两个字串线性扫描的16 + 8 = 24的操作。(随着字串长度的增长,你会发现这个算法的效果会越来越好)

    关于采用何种排序方法,我们采用最常用的快速排序,下面的快速排序的代码用的是以前写的,比较好懂,并且,我执意不用库函数的qsort代码。唯一的问题是,此前写的代码是针对整数进行排序的,不过,难不倒我们,稍微改一下参数,即可,如下:

  1. //copyright@ 2011 July && yansha  
  2. //July,updated,2011.04.23.  
  3. #include <iostream>  
  4. #include <string>  
  5. using namespace std;  
  6.   
  7. //以前的注释,还让它保留着  
  8. int partition(string &str,int lo,int hi)   
  9. {  
  10.     int key = str[hi];      //以最后一个元素,data[hi]为主元  
  11.     int i = lo - 1;  
  12.     for(int j = lo; j < hi; j++) ///注,j从p指向的是r-1,不是r。  
  13.     {  
  14.         if(str[j] <= key)  
  15.         {  
  16.             i++;  
  17.             swap(str[i], str[j]);  
  18.         }  
  19.     }  
  20.     swap(str[i+1], str[hi]);    //不能改为swap(&data[i+1],&key)  
  21.     return i + 1;   
  22. }  
  23.   
  24. //递归调用上述partition过程,完成排序。  
  25. void quicksort(string &str, int lo, int hi)  
  26. {  
  27.     if (lo < hi)  
  28.     {  
  29.         int k = partition(str, lo, hi);  
  30.         quicksort(str, lo, k - 1);  
  31.         quicksort(str, k + 1, hi);  
  32.     }  
  33. }  
  34.   
  35. //比较,上述排序O(m log m) + O(n log n),加上下面的O(m+n),  
  36. //时间复杂度总计为:O(mlogm)+O(nlogn)+O(m+n)。  
  37. void compare(string str1,string str2)  
  38. {  
  39.     int posOne = 0;  
  40.     int posTwo = 0;  
  41.     while (posTwo < str2.length() && posOne < str1.length())  
  42.     {  
  43.         while (str1[posOne] < str2[posTwo] && posOne < str1.length() - 1)  
  44.             posOne++;  
  45.         //如果和str2相等,那就不能动。只有比str2小,才能动。  
  46.           
  47.         if (str1[posOne] != str2[posTwo])  
  48.             break;  
  49.           
  50.         //posOne++;     
  51.         //归并的时候,str1[str1Pos] == str[str2Pos]的时候,只能str2Pos++,str1Pos不可以自增。  
  52.         //多谢helloword指正。  
  53.   
  54.         posTwo++;  
  55.     }  
  56.                   
  57.     if (posTwo == str2.length())  
  58.         cout << "true" << endl;  
  59.     else  
  60.         cout << "false" << endl;  
  61. }  
  62.   
  63. int main()   
  64. {   
  65.     string str1 = "ABCDEFGHLMNOPQRS";  
  66.     string str2 = "DCGDSRQPOM";    
  67.     //之前上面加了那句posOne++之所以有bug,是因为,@helloword:  
  68.     //因为str1如果也只有一个D,一旦posOne++,就到了下一个不是'D'的字符上去了,  
  69.     //而str2有俩D,posTwo++后,下一个字符还是'D',就不等了,出现误判。  
  70.   
  71.     quicksort(str1, 0, str1.length() - 1);  
  72.     quicksort(str2, 0, str2.length() - 1);  //先排序  
  73.     compare(str1, str2);                    //后线性扫描  
  74.     return 0;  
  75. }  
    

1.3、O(n+m)的计数排序方法

    此方案与上述思路相比,就是在排序的时候采用线性时间的计数排序方法,排序O(n+m),线性扫描O(n+m),总计时间复杂度为:O(n+m)+O(n+m)=O(n+m)

    代码如下:

  1. #include <iostream>  
  2. #include <string>  
  3. using namespace std;  
  4.   
  5. // 计数排序,O(n+m)  
  6. void CounterSort(string str, string &help_str)  
  7. {  
  8.     // 辅助计数数组  
  9.     int help[26] = {0};  
  10.   
  11.     // help[index]存放了等于index + 'A'的元素个数  
  12.     for (int i = 0; i < str.length(); i++)  
  13.     {  
  14.         int index = str[i] - 'A';  
  15.         help[index]++;  
  16.     }  
  17.   
  18.     // 求出每个元素对应的最终位置  
  19.     for (int j = 1; j < 26; j++)  
  20.         help[j] += help[j-1];  
  21.   
  22.     // 把每个元素放到其对应的最终位置  
  23.     for (int k = str.length() - 1; k >= 0; k--)  
  24.     {  
  25.         int index = str[k] - 'A';  
  26.         int pos = help[index] - 1;  
  27.         help_str[pos] = str[k];  
  28.         help[index]--;  
  29.     }  
  30. }  
  31.   
  32. //线性扫描O(n+m)  
  33. void Compare(string long_str,string short_str)  
  34. {  
  35.     int pos_long = 0;  
  36.     int pos_short = 0;  
  37.     while (pos_short < short_str.length() && pos_long < long_str.length())  
  38.     {  
  39.         // 如果pos_long递增直到long_str[pos_long] >= short_str[pos_short]  
  40.         while (long_str[pos_long] < short_str[pos_short] && pos_long < long_str.length  
  41.   
  42. () - 1)  
  43.             pos_long++;  
  44.           
  45.         // 如果short_str有连续重复的字符,pos_short递增  
  46.         while (short_str[pos_short] == short_str[pos_short+1])  
  47.             pos_short++;  
  48.   
  49.         if (long_str[pos_long] != short_str[pos_short])  
  50.             break;  
  51.           
  52.         pos_long++;  
  53.         pos_short++;  
  54.     }  
  55.       
  56.     if (pos_short == short_str.length())  
  57.         cout << "true" << endl;  
  58.     else  
  59.         cout << "false" << endl;  
  60. }  
  61.   
  62. int main()  
  63. {  
  64.     string strOne = "ABCDAK";  
  65.     string strTwo = "A";  
  66.     string long_str = strOne;  
  67.     string short_str = strTwo;  
  68.   
  69.     // 对字符串进行计数排序  
  70.     CounterSort(strOne, long_str);  
  71.     CounterSort(strTwo, short_str);  
  72.   
  73.     // 比较排序好的字符串  
  74.     Compare(long_str, short_str);  
  75.     return 0;  
  76. }  

 不过上述方法,空间复杂度为O(n+m),即消耗了一定的空间。有没有在线性时间,且空间复杂度较小的方案列?

 

第二节、寻求线性时间的解法
2.1、O(n+m)的hashtable的方法
    上述方案中,较好的方法是先对字符串进行排序,然后再线性扫描,总的时间复杂度已经优化到了:O(m+n),貌似到了极限,还有没有更好的办法列?

    我们可以对短字串进行轮询(此思路的叙述可能与网上的一些叙述有出入,因为我们最好是应该把短的先存储,那样,会降低题目的时间复杂度),把其中的每个字母都放入一个Hashtable里(我们始终设m为短字符串的长度,那么此项操作成本是O(m)或8次操作)。然后轮询长字符串,在Hashtable里查询短字符串的每个字符,看能否找到。如果找不到,说明没有匹配成功,轮询长字符串将消耗掉16次操作,这样两项操作加起来一共只有8+16=24次。
    当然,理想情况是如果长字串的前缀就为短字串,只需消耗8次操作,这样总共只需8+8=16次。

    或如梦想天窗所说: 我之前用散列表做过一次,算法如下:
 1、hash[26],先全部清零,然后扫描短的字符串,若有相应的置1,
 2、计算hash[26]中1的个数,记为m 
 3、扫描长字符串的每个字符a;若原来hash[a] == 1 ,则修改hash[a] = 0,并将m减1;若hash[a] == 0,则不做处理 
 4、若m == 0 or 扫描结束,退出循环。

    代码实现,也不难,如下:

  1. //copyright@ 2011 yansha  
  2. //July、updated,2011.04.25。   
  3. #include <iostream>  
  4. #include <string>  
  5. using namespace std;  
  6.   
  7. int main()  
  8. {  
  9.     string str1="ABCDEFGHLMNOPQRS";  
  10.     string str2="DCGSRQPOM";  
  11.   
  12.     // 开辟一个辅助数组并清零  
  13.     int hash[26] = {0};  
  14.   
  15.     // num为辅助数组中元素个数  
  16.     int num = 0;  
  17.   
  18.     // 扫描短字符串  
  19.     for (int j = 0; j < str2.length(); j++)  
  20.     {  
  21.         // 将字符转换成对应辅助数组中的索引  
  22.         int index = str1[j] - 'A';  
  23.   
  24.         // 如果辅助数组中该索引对应元素为0,则置1,且num++;  
  25.         if (hash[index] == 0)  
  26.         {  
  27.             hash[index] = 1;  
  28.             num++;  
  29.         }  
  30.     }  
  31.   
  32.     // 扫描长字符串  
  33.     for (int k = 0; k < str1.length(); k++)  
  34.     {  
  35.         int index = str1[k] - 'A';  
  36.   
  37.         // 如果辅助数组中该索引对应元素为1,则num--;为零的话,不作处理(不写语句)。  
  38.         if(hash[index] ==1)  
  39.         {  
  40.             hash[index] = 0;  
  41.             num--;  
  42.             if(num == 0)    //m==0,即退出循环。  
  43.                 break;  
  44.         }  
  45.     }  
  46.   
  47.     // num为0说明长字符串包含短字符串内所有字符  
  48.     if (num == 0)  
  49.         cout << "true" << endl;  
  50.     else  
  51.         cout << "false" << endl;  
  52.     return 0;  
  53. }  

 

2.2、O(n+m)的数组存储方法

    有两个字符串short_str和long_str。
    第一步:你标记short_str中有哪些字符,在store数组中标记为true。(store数组起一个映射的作用,如果有A,则将第1个单元标记true,如果有B,则将第2个单元标记true,... 如果有Z, 则将第26个单元标记true)
    第二步:遍历long_str,如果long_str中的字符包括short_str中的字符则将store数组中对应位置标记为false。(如果有A,则将第1个单元标记false,如果有B,则将第2个单元标记false,... 如果有Z, 则将第26个单元标记false),如果没有,则不作处理。
    第三步:此后,遍历store数组,如果所有的元素都是false,也就说明store_str中字符都包含在long_str内,输出true。否则,输出false。

    举个简单的例子好了,如abcd,abcdefg两个字符串,
    1、先遍历短字符串abcd,在store数组中相对应的abcd的位置上的单元元素置为true,
    2、然后遍历abcdefg,在store数组中相应的abcd位置上,发现已经有了abcd,则前4个的单元元素都置为false,当我们已经遍历了4个元素,等于了短字符串abcd的4个数目,所以,满足条件,退出。
    (不然,继续遍历的话,我们会发现efg在store数组中没有元素,不作处理。最后,自然,就会发现store数组中的元素单元都是false的。)
    3、遍历store数组,发现所有的元素都已被置为false,所以程序输出true。

    其实,这个思路和上一节中,O(n+m)的hashtable的方法代码,原理是完全一致的,且本质上都采用的数组存储(hash表也是一个数组),但我并不认为此思路多此一举,所以仍然贴出来。ok,代码如下:

  1. //copyright@ 2011 Hession  
  2. //July、updated,2011.04.23.  
  3. #include<iostream>  
  4. #include<string.h>  
  5. using namespace std;  
  6.   
  7. int main()  
  8. {  
  9.     char long_ch[]="ABCDEFGHLMNOPQRS";  
  10.     char short_ch[]="DEFGHXLMNOPQ";  
  11.     int i;  
  12.     bool store[58];  
  13.     memset(store,false,58);    
  14.       
  15.     //前两个 是  遍历 两个字符串, 后面一个是  遍历 数组  
  16.     for(i=0;i<sizeof(short_ch)-1;i++)  
  17.         store[short_ch[i]-65]=true;  
  18.       
  19.     for(i=0;i<sizeof(long_ch)-1;i++)  
  20.     {  
  21.         if(store[long_ch[i]-65]!=false)  
  22.             store[long_ch[i]-65]=false;  
  23.     }  
  24.     for(i=0;i<58;i++)  
  25.     {  
  26.         if(store[i]!=false)  
  27.         {  
  28.             cout<<"short_ch is not in long_ch"<<endl;  
  29.             break;    
  30.         }          
  31.         if(i==57)  
  32.             cout<<"short_ch is in long_ch"<<endl;  
  33.     }  
  34.       
  35.     return 0;  
  36. }  

 

第三节、O(n)到O(n+m)的素数方法

    我想问的是,还有更好的方案么?
    你可能会这么想:O(n+m)是你能得到的最好的结果了,至少要对每个字母至少访问一次才能完成这项操作,而上一节最后的俩个方案是刚好是对每个字母只访问一次。

    ok,下面给出一个更好的方案:
    假设我们有一个一定个数的字母组成字串,我给每个字母分配一个素数,从2开始,往后类推。这样A将会是2,B将会是3,C将会是5,等等。现在我遍历第一个字串,把每个字母代表的素数相乘。你最终会得到一个很大的整数,对吧?
    然后——轮询第二个字符串,用每个字母除它。如果除的结果有余数,这说明有不匹配的字母。如果整个过程中没有余数,你应该知道它是第一个字串恰好的子集了。

思路总结如下:
1.定义最小的26个素数分别与字符'A'到'Z'对应。
2.遍历长字符串,求得每个字符对应素数的乘积。
3.遍历短字符串,判断乘积能否被短字符串中的字符对应的素数整除。
4.输出结果。

    至此,如上所述,上述算法的时间复杂度为O(m+n),时间复杂度最好的情况为O(n)(遍历短的字符串的第一个数,与长字符串素数的乘积相除,即出现余数,便可退出程序,返回false),n为长字串的长度,空间复杂度为O(1)。如你所见,我们已经优化到了最好的程度。

    不过,正如原文中所述:“现在我想告诉你 —— Guy的方案在算法上并不能说就比我的好。而且在实际操作中,你很可能仍会使用我的方案,因为它更通用,无需跟麻烦的大型数字打交道。但从”巧妙水平“上讲,Guy提供的是一种更、更、更有趣的方案。”

    ok,如果你有更好的思路,欢迎在本文的评论中给出,非常感谢。

  1. #include <iostream>  
  2. #include <string>  
  3. #include "BigInt.h"  
  4. using namespace std;  
  5.   
  6. // 素数数组  
  7. int primeNumber[26] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,  
  8.                         61, 67, 71, 73, 79, 83, 89, 97, 101};  
  9.   
  10. int main()  
  11. {  
  12.     string strOne = "ABCDEFGHLMNOPQRS";  
  13.     string strTwo = "DCGSRQPOM";  
  14.   
  15.     // 这里需要用到大整数  
  16.     CBigInt product = 1;   //大整数除法的代码,下头给出。  
  17.   
  18.     // 遍历长字符串,得到每个字符对应素数的乘积  
  19.     for (int i = 0; i < strOne.length(); i++)  
  20.     {  
  21.         int index = strOne[i] - 'A';  
  22.         product = product * primeNumber[index];  
  23.     }  
  24.   
  25.     // 遍历短字符串  
  26.     for (int j = 0; j < strTwo.length(); j++)  
  27.     {  
  28.         int index = strTwo[j] - 'A';  
  29.   
  30.         // 如果余数不为0,说明不包括短字串中的字符,跳出循环  
  31.         if (product % primeNumber[index] != 0)  
  32.             break;  
  33.     }  
  34.   
  35.     // 如果积能整除短字符串中所有字符则输出"true",否则输出"false"。  
  36.     if (strTwo.length() == j)  
  37.         cout << "true" << endl;  
  38.     else  
  39.         cout << "false" << endl;  
  40.     return 0;  
  41. }  
     

上述程序待改进的地方:
1.只考虑大写字符,如果考虑小写字符和数组的话,素数数组需要更多素数
2.没有考虑重复的字符,可以加入判断重复字符的辅助数组。

大整数除法的代码,后续公布下载地址。

    说明:此次的判断字符串是否包含问题,来自一位外国网友提供的gofish、google面试题,这个题目出自此篇文章:http://www.aqee.net/2011/04/11/google-interviewing-story/,文章记录了整个面试的过程,比较有趣,值得一读。

    扩展:正如网友安逸所说:其实这个问题还可以转换为:a和b两个字符串,求b串包含a串的最小长度。包含指的就是b的字串包含a中每个字符。


updated:我们假设字母都由大写字母组成……,我们先对小字符串预处理,可以得到B里包含哪些字符,这里可以用位运算,或者用bool数组。位运算简单些,用一个int中的26bit表示其是否在B中出现即可。

  1. //copyright@ caopengcs 2013  
  2. bool AcontainsB(char *A,char *B) {    
  3.     int have = 0;    
  4.     while (*B) {    
  5.         have |= 1 << (*(B++) - 'A');   // 把A..Z对应为0..26    
  6.     }    
  7.     while (*A) {    
  8.         if ((have & (1 << (*(A++) - 'A'))) == 0) {    
  9.             return false;    
  10.         }    
  11.     }    
  12.     return true;    
  13. }    
0
0

猜你在找
【直播】机器学习&数据挖掘7周实训--韦玮
【套餐】系统集成项目管理工程师顺利通关--徐朋
【直播】3小时掌握Docker最佳实战-徐西宁
【套餐】机器学习系列套餐(算法+实战)--唐宇迪
【直播】计算机视觉原理及实战--屈教授
【套餐】微信订阅号+服务号Java版 v2.0--翟东平
【直播】机器学习之矩阵--黄博士
【套餐】微信订阅号+服务号Java版 v2.0--翟东平
【直播】机器学习之凸优化--马博士
【套餐】Javascript 设计模式实战--曾亮
查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:316456次
    • 积分:4438
    • 等级:
    • 排名:第6665名
    • 原创:5篇
    • 转载:589篇
    • 译文:0篇
    • 评论:5条
    最新评论