程序员编程艺术：第二章、字符串是否包含问题
2013-12-03 21:36
555 查看
文章转载：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中。
代码可如下编写：
//copyright@啊菜 2011
//updated@July&Image丶时光 2013
#include <iostream>
#include <string>
using namespace std;
int CompareString(string LongString,string ShortString)
{
int i,j;
for (i=0; i<ShortString.length(); i++)
{
for (j=0; j<LongString.length(); j++) //O(n*m)
{
if (LongString[j] == ShortString[i]) //一一比较
{
break;
}
}
if (j==LongString.length())
{
cout << "false" << endl;
return 0;
}
}
cout << "true" << endl;
return 1;
}
int main()
{
string LongString="ABCDEFGHLMNOPQRS";
string ShortString="DCGSRQPO";
CompareString(LongString,ShortString);
return 0;
}
假设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代码。唯一的问题是，此前写的代码是针对整数进行排序的，不过，难不倒我们，稍微改一下参数，即可，如下：
//copyright@ 2011 July && yansha
//July，updated，2011.04.23.
#include <iostream>
#include <string>
using namespace std;
//以前的注释，还让它保留着
int partition(string &str,int lo,int hi)
{
int key = str[hi]; //以最后一个元素，data[hi]为主元
int i = lo - 1;
for(int j = lo; j < hi; j++) ///注，j从p指向的是r-1，不是r。
{
if(str[j] <= key)
{
i++;
swap(str[i], str[j]);
}
}
swap(str[i+1], str[hi]); //不能改为swap(&data[i+1],&key)
return i + 1;
}
//递归调用上述partition过程，完成排序。
void quicksort(string &str, int lo, int hi)
{
if (lo < hi)
{
int k = partition(str, lo, hi);
quicksort(str, lo, k - 1);
quicksort(str, k + 1, hi);
}
}
//比较，上述排序O(m log m) + O(n log n)，加上下面的O(m+n)，
//时间复杂度总计为：O(mlogm)+O(nlogn)+O(m+n)。
void compare(string str1,string str2)
{
int posOne = 0;
int posTwo = 0;
while (posTwo < str2.length() && posOne < str1.length())
{
while (str1[posOne] < str2[posTwo] && posOne < str1.length() - 1)
posOne++;
//如果和str2相等，那就不能动。只有比str2小，才能动。
if (str1[posOne] != str2[posTwo])
break;
//posOne++;
//归并的时候，str1[str1Pos] == str[str2Pos]的时候，只能str2Pos++,str1Pos不可以自增。
//多谢helloword指正。
posTwo++;
}
if (posTwo == str2.length())
cout << "true" << endl;
else
cout << "false" << endl;
}
int main()
{
string str1 = "ABCDEFGHLMNOPQRS";
string str2 = "DCGDSRQPOM";
//之前上面加了那句posOne++之所以有bug，是因为，@helloword：
//因为str1如果也只有一个D，一旦posOne++，就到了下一个不是'D'的字符上去了，
//而str2有俩D，posTwo++后，下一个字符还是'D'，就不等了，出现误判。
quicksort(str1, 0, str1.length() - 1);
quicksort(str2, 0, str2.length() - 1); //先排序
compare(str1, str2); //后线性扫描
return 0;
}
1.3、O（n+m）的计数排序方法
此方案与上述思路相比，就是在排序的时候采用线性时间的计数排序方法，排序O（n+m），线性扫描O（n+m），总计时间复杂度为：O（n+m）+O（n+m）=O（n+m）。
代码如下：
#include <iostream>
#include <string>
using namespace std;
// 计数排序，O（n+m）
void CounterSort(string str, string &help_str)
{
// 辅助计数数组
int help[26] = {0};
// help[index]存放了等于index + 'A'的元素个数
for (int i = 0; i < str.length(); i++)
{
int index = str[i] - 'A';
help[index]++;
}
// 求出每个元素对应的最终位置
for (int j = 1; j < 26; j++)
help[j] += help[j-1];
// 把每个元素放到其对应的最终位置
for (int k = str.length() - 1; k >= 0; k--)
{
int index = str[k] - 'A';
int pos = help[index] - 1;
help_str[pos] = str[k];
help[index]--;
}
}
//线性扫描O（n+m）
void Compare(string long_str,string short_str)
{
int pos_long = 0;
int pos_short = 0;
while (pos_short < short_str.length() && pos_long < long_str.length())
{
// 如果pos_long递增直到long_str[pos_long] >= short_str[pos_short]
while (long_str[pos_long] < short_str[pos_short] && pos_long < long_str.length
() - 1)
pos_long++;
// 如果short_str有连续重复的字符，pos_short递增
while (short_str[pos_short] == short_str[pos_short+1])
pos_short++;
if (long_str[pos_long] != short_str[pos_short])
break;
pos_long++;
pos_short++;
}
if (pos_short == short_str.length())
cout << "true" << endl;
else
cout << "false" << endl;
}
int main()
{
string strOne = "ABCDAK";
string strTwo = "A";
string long_str = strOne;
string short_str = strTwo;
// 对字符串进行计数排序
CounterSort(strOne, long_str);
CounterSort(strTwo, short_str);
// 比较排序好的字符串
Compare(long_str, short_str);
return 0;
}
不过上述方法，空间复杂度为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 扫描结束，退出循环。
代码实现，也不难，如下：
//copyright@ 2011 yansha
//July、updated，2011.04.25。
#include <iostream>
#include <string>
using namespace std;
int main()
{
string str1="ABCDEFGHLMNOPQRS";
string str2="DCGSRQPOM";
// 开辟一个辅助数组并清零
int hash[26] = {0};
// num为辅助数组中元素个数
int num = 0;
// 扫描短字符串
for (int j = 0; j < str2.length(); j++)
{
// 将字符转换成对应辅助数组中的索引
int index = str1[j] - 'A';
// 如果辅助数组中该索引对应元素为0，则置1，且num++;
if (hash[index] == 0)
{
hash[index] = 1;
num++;
}
}
// 扫描长字符串
for (int k = 0; k < str1.length(); k++)
{
int index = str1[k] - 'A';
// 如果辅助数组中该索引对应元素为1，则num--;为零的话，不作处理（不写语句）。
if(hash[index] ==1)
{
hash[index] = 0;
num--;
if(num == 0) //m==0，即退出循环。
break;
}
}
// num为0说明长字符串包含短字符串内所有字符
if (num == 0)
cout << "true" << endl;
else
cout << "false" << endl;
return 0;
}
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，代码如下：
//copyright@ 2011 Hession
//July、updated，2011.04.23.
#include<iostream>
#include<string.h>
using namespace std;
int main()
{
char long_ch[]="ABCDEFGHLMNOPQRS";
char short_ch[]="DEFGHXLMNOPQ";
int i;
bool store[58];
memset(store,false,58);
//前两个 是 遍历 两个字符串, 后面一个是 遍历 数组
for(i=0;i<sizeof(short_ch)-1;i++)
store[short_ch[i]-65]=true;
for(i=0;i<sizeof(long_ch)-1;i++)
{
if(store[long_ch[i]-65]!=false)
store[long_ch[i]-65]=false;
}
for(i=0;i<58;i++)
{
if(store[i]!=false)
{
cout<<"short_ch is not in long_ch"<<endl;
break;
}
if(i==57)
cout<<"short_ch is in long_ch"<<endl;
}
return 0;
}
第三节、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，如果你有更好的思路，欢迎在本文的评论中给出，非常感谢。
#include <iostream>
#include <string>
#include "BigInt.h"
using namespace std;
// 素数数组
int primeNumber[26] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
61, 67, 71, 73, 79, 83, 89, 97, 101};
int main()
{
string strOne = "ABCDEFGHLMNOPQRS";
string strTwo = "DCGSRQPOM";
// 这里需要用到大整数
CBigInt product = 1; //大整数除法的代码，下头给出。
// 遍历长字符串，得到每个字符对应素数的乘积
for (int i = 0; i < strOne.length(); i++)
{
int index = strOne[i] - 'A';
product = product * primeNumber[index];
}
// 遍历短字符串
for (int j = 0; j < strTwo.length(); j++)
{
int index = strTwo[j] - 'A';
// 如果余数不为0，说明不包括短字串中的字符，跳出循环
if (product % primeNumber[index] != 0)
break;
}
// 如果积能整除短字符串中所有字符则输出"true"，否则输出"false"。
if (strTwo.length() == j)
cout << "true" << endl;
else
cout << "false" << endl;
return 0;
}
上述程序待改进的地方：
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中出现即可。
//copyright@ caopengcs 2013
bool AcontainsB(char *A,char *B) {
int have = 0;
while (*B) {
have |= 1 << (*(B++) - 'A'); // 把A..Z对应为0..26
}
while (*A) {
if ((have & (1 << (*(A++) - 'A'))) == 0) {
return false;
}
}
return true;
}
程序员编程艺术：第二章、字符串是否包含问题
作者：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中。
代码可如下编写：
//copyright@啊菜 2011
//updated@July&Image丶时光 2013
#include <iostream>
#include <string>
using namespace std;
int CompareString(string LongString,string ShortString)
{
int i,j;
for (i=0; i<ShortString.length(); i++)
{
for (j=0; j<LongString.length(); j++) //O(n*m)
{
if (LongString[j] == ShortString[i]) //一一比较
{
break;
}
}
if (j==LongString.length())
{
cout << "false" << endl;
return 0;
}
}
cout << "true" << endl;
return 1;
}
int main()
{
string LongString="ABCDEFGHLMNOPQRS";
string ShortString="DCGSRQPO";
CompareString(LongString,ShortString);
return 0;
}
假设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代码。唯一的问题是，此前写的代码是针对整数进行排序的，不过，难不倒我们，稍微改一下参数，即可，如下：
//copyright@ 2011 July && yansha
//July，updated，2011.04.23.
#include <iostream>
#include <string>
using namespace std;
//以前的注释，还让它保留着
int partition(string &str,int lo,int hi)
{
int key = str[hi]; //以最后一个元素，data[hi]为主元
int i = lo - 1;
for(int j = lo; j < hi; j++) ///注，j从p指向的是r-1，不是r。
{
if(str[j] <= key)
{
i++;
swap(str[i], str[j]);
}
}
swap(str[i+1], str[hi]); //不能改为swap(&data[i+1],&key)
return i + 1;
}
//递归调用上述partition过程，完成排序。
void quicksort(string &str, int lo, int hi)
{
if (lo < hi)
{
int k = partition(str, lo, hi);
quicksort(str, lo, k - 1);
quicksort(str, k + 1, hi);
}
}
//比较，上述排序O(m log m) + O(n log n)，加上下面的O(m+n)，
//时间复杂度总计为：O(mlogm)+O(nlogn)+O(m+n)。
void compare(string str1,string str2)
{
int posOne = 0;
int posTwo = 0;
while (posTwo < str2.length() && posOne < str1.length())
{
while (str1[posOne] < str2[posTwo] && posOne < str1.length() - 1)
posOne++;
//如果和str2相等，那就不能动。只有比str2小，才能动。
if (str1[posOne] != str2[posTwo])
break;
//posOne++;
//归并的时候，str1[str1Pos] == str[str2Pos]的时候，只能str2Pos++,str1Pos不可以自增。
//多谢helloword指正。
posTwo++;
}
if (posTwo == str2.length())
cout << "true" << endl;
else
cout << "false" << endl;
}
int main()
{
string str1 = "ABCDEFGHLMNOPQRS";
string str2 = "DCGDSRQPOM";
//之前上面加了那句posOne++之所以有bug，是因为，@helloword：
//因为str1如果也只有一个D，一旦posOne++，就到了下一个不是'D'的字符上去了，
//而str2有俩D，posTwo++后，下一个字符还是'D'，就不等了，出现误判。
quicksort(str1, 0, str1.length() - 1);
quicksort(str2, 0, str2.length() - 1); //先排序
compare(str1, str2); //后线性扫描
return 0;
}
1.3、O（n+m）的计数排序方法
此方案与上述思路相比，就是在排序的时候采用线性时间的计数排序方法，排序O（n+m），线性扫描O（n+m），总计时间复杂度为：O（n+m）+O（n+m）=O（n+m）。
代码如下：
#include <iostream>
#include <string>
using namespace std;
// 计数排序，O（n+m）
void CounterSort(string str, string &help_str)
{
// 辅助计数数组
int help[26] = {0};
// help[index]存放了等于index + 'A'的元素个数
for (int i = 0; i < str.length(); i++)
{
int index = str[i] - 'A';
help[index]++;
}
// 求出每个元素对应的最终位置
for (int j = 1; j < 26; j++)
help[j] += help[j-1];
// 把每个元素放到其对应的最终位置
for (int k = str.length() - 1; k >= 0; k--)
{
int index = str[k] - 'A';
int pos = help[index] - 1;
help_str[pos] = str[k];
help[index]--;
}
}
//线性扫描O（n+m）
void Compare(string long_str,string short_str)
{
int pos_long = 0;
int pos_short = 0;
while (pos_short < short_str.length() && pos_long < long_str.length())
{
// 如果pos_long递增直到long_str[pos_long] >= short_str[pos_short]
while (long_str[pos_long] < short_str[pos_short] && pos_long < long_str.length
() - 1)
pos_long++;
// 如果short_str有连续重复的字符，pos_short递增
while (short_str[pos_short] == short_str[pos_short+1])
pos_short++;
if (long_str[pos_long] != short_str[pos_short])
break;
pos_long++;
pos_short++;
}
if (pos_short == short_str.length())
cout << "true" << endl;
else
cout << "false" << endl;
}
int main()
{
string strOne = "ABCDAK";
string strTwo = "A";
string long_str = strOne;
string short_str = strTwo;
// 对字符串进行计数排序
CounterSort(strOne, long_str);
CounterSort(strTwo, short_str);
// 比较排序好的字符串
Compare(long_str, short_str);
return 0;
}
不过上述方法，空间复杂度为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 扫描结束，退出循环。
代码实现，也不难，如下：
//copyright@ 2011 yansha
//July、updated，2011.04.25。
#include <iostream>
#include <string>
using namespace std;
int main()
{
string str1="ABCDEFGHLMNOPQRS";
string str2="DCGSRQPOM";
// 开辟一个辅助数组并清零
int hash[26] = {0};
// num为辅助数组中元素个数
int num = 0;
// 扫描短字符串
for (int j = 0; j < str2.length(); j++)
{
// 将字符转换成对应辅助数组中的索引
int index = str1[j] - 'A';
// 如果辅助数组中该索引对应元素为0，则置1，且num++;
if (hash[index] == 0)
{
hash[index] = 1;
num++;
}
}
// 扫描长字符串
for (int k = 0; k < str1.length(); k++)
{
int index = str1[k] - 'A';
// 如果辅助数组中该索引对应元素为1，则num--;为零的话，不作处理（不写语句）。
if(hash[index] ==1)
{
hash[index] = 0;
num--;
if(num == 0) //m==0，即退出循环。
break;
}
}
// num为0说明长字符串包含短字符串内所有字符
if (num == 0)
cout << "true" << endl;
else
cout << "false" << endl;
return 0;
}
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，代码如下：
//copyright@ 2011 Hession
//July、updated，2011.04.23.
#include<iostream>
#include<string.h>
using namespace std;
int main()
{
char long_ch[]="ABCDEFGHLMNOPQRS";
char short_ch[]="DEFGHXLMNOPQ";
int i;
bool store[58];
memset(store,false,58);
//前两个 是 遍历 两个字符串, 后面一个是 遍历 数组
for(i=0;i<sizeof(short_ch)-1;i++)
store[short_ch[i]-65]=true;
for(i=0;i<sizeof(long_ch)-1;i++)
{
if(store[long_ch[i]-65]!=false)
store[long_ch[i]-65]=false;
}
for(i=0;i<58;i++)
{
if(store[i]!=false)
{
cout<<"short_ch is not in long_ch"<<endl;
break;
}
if(i==57)
cout<<"short_ch is in long_ch"<<endl;
}
return 0;
}
第三节、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，如果你有更好的思路，欢迎在本文的评论中给出，非常感谢。
#include <iostream>
#include <string>
#include "BigInt.h"
using namespace std;
// 素数数组
int primeNumber[26] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
61, 67, 71, 73, 79, 83, 89, 97, 101};
int main()
{
string strOne = "ABCDEFGHLMNOPQRS";
string strTwo = "DCGSRQPOM";
// 这里需要用到大整数
CBigInt product = 1; //大整数除法的代码，下头给出。
// 遍历长字符串，得到每个字符对应素数的乘积
for (int i = 0; i < strOne.length(); i++)
{
int index = strOne[i] - 'A';
product = product * primeNumber[index];
}
// 遍历短字符串
for (int j = 0; j < strTwo.length(); j++)
{
int index = strTwo[j] - 'A';
// 如果余数不为0，说明不包括短字串中的字符，跳出循环
if (product % primeNumber[index] != 0)
break;
}
// 如果积能整除短字符串中所有字符则输出"true"，否则输出"false"。
if (strTwo.length() == j)
cout << "true" << endl;
else
cout << "false" << endl;
return 0;
}
上述程序待改进的地方：
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中出现即可。
//copyright@ caopengcs 2013
bool AcontainsB(char *A,char *B) {
int have = 0;
while (*B) {
have |= 1 << (*(B++) - 'A'); // 把A..Z对应为0..26
}
while (*A) {
if ((have & (1 << (*(A++) - 'A'))) == 0) {
return false;
}
}
return true;
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 程序员编程艺术：第二章、字符串是否包含及匹配/查找/转换/拷贝问题
- 程序员编程艺术：第二章、字符串是否包含问题
- 程序员编程艺术：第二章、字符串是否包含及匹配/查找/转换/拷贝问题
- 程序员编程艺术：第二章、字符串是否包含问题
- 程序员编程艺术：第二章、字符串是否包含及匹配/查找/转换/拷贝问题
- 程序员编程艺术：第二章、字符串是否包含问题
- 程序员编程艺术：第二章、字符串是否包含及匹配/查找/转换/拷贝问题
- 程序员编程艺术：第二章、字符串是否包含问题
- 程序员编程艺术：第二章、字符串是否包含问题
- 程序员编程艺术：第二章、字符串是否包含及匹配/查找/转换/拷贝问题
- 程序员编程艺术：第二章、字符串是否包含问题
- 程序员编程艺术：第二章、字符串是否包含及匹配/查找/转换/拷贝问题
- [整理]程序员编程艺术：第二章、字符串是否包含问题
- 程序员编程艺术：第二章、字符串是否包含及匹配/查找/转换/拷贝问题
- 个人解法 ------- 程序员编程艺术：第二章、字符串是否包含问题
- 【程序员编程艺术】第二章：字符串是否包含问题
- 程序员编程艺术2：字符串是否包含问题
- 程序员编程艺术学习笔记(二)字符串是否包含问题
- 读程序员编程艺术第二章---字符串包含问题
- 读程序员编程艺术第二章---字符串包含问题(二)