问题：

实现一个挺高级的字符匹配算法：
给一串很长字符串，要求找到符合要求的字符串，例如目的串：123
1******3***2 ,12*****3这些都要找出来
其实就是类似一些和谐系统。。。。。

分析：

这题的真正意思就是，给你一个目标串，如“123”，只要一个字符串里面同时包含1、2和3，那么这个字符串就匹配了。系统越和谐，说明错杀的可能行也就越大。加入目标串的长度为m，模式串的长度为n，我们很容易想到O(mn)的算法，就是两遍for循环搞定（就是找一个子串）。那么有没有更快的方法呢？

   我们考虑问题的时候，如果想时间变得快，有一种方法就叫做“空间换时间”。哈希表是一种比较复杂的数据结构。由于比较复杂，STL中没有实现哈希表，因此需要我们自己实现一个。但由于本题的特殊性，我们只需要一个非常简单的哈希表就能满足要求。由于字符（char）是一个长度为8的数据类型，因此总共有可能256 种可能。于是我们创建一个长度为256的数组，每个字母根据其ASCII码值作为数组的下标对应数组的对应项，而数组中存储的0、1对应每个字符是否出现。这样我们就创建了一个大小为256，以字符ASCII码为键值的哈希表。（并不仅限于英文字符，所以这里要考虑256种可能）。

       知道了这点，我们可以构建一个数组来统计模式串中某个字符是否出现，然后在对目标串进行扫描，看看对应的所有位上是否出现，从而判断是否匹配。分析一下复杂度，大概是O(m+n)。

代码如下：

[cpp] 
view plain
copy

1. //强大的和谐系统  
2. int is_contain(char *src, char *des)  
3. {  
4.     //创建一个哈希表，并初始化  
5.     const int tableSize = 256;  
6.     int hashTable[tableSize];  
7.     int len,i;  
8.   
9.     for(i = 0; i < tableSize; i++)  
10.         hashTable[i] = 0;  
11.   
12.     len = strlen(src);  
13.     for(i = 0; i < len; i++)  
14.         hashTable[src[i]] = 1;  
15.   
16.     len = strlen(des);  
17.     for(i = 0; i < len; i++)  
18.     {  
19.         if(hashTable[des[i]] == 0)  
20.             return 0;         //匹配失败  
21.     }  
22.     return 1;    //匹配成功  
23. }  

与此题类似：给一个很长的字符串str， 还有一个字符集比如{a，b，c}，找出str包含{a，b，c}的最短子串，要求O（n）。

[cpp] 
view plain
copy

1. /* 
2. 用两个变量 front,rear 指向一个的子串区间的头和尾（当然，开始时front和rear都指向字符串开始处）。 
3. 用一个int cnt[255]={0}记录当前这个子串里字符集a,b,c各自的个数，一个变量count记录字符集里有多少个了 
4. rear 一直加，更新cnt[]和count的值，直到count等于字符集个数 
5. 然后front++,直到cnt[]里某个字符个数为0（front 开始的部分有可能和后面的重复，所以front要加到某个字符个数为0）， 
6. 这样就找到一个符合条件的字串了,继续下去，可以求出所有符合条件的串，同时可以求出满足条件最短子串 
7.  
8. */  
9.   
10. #include <iostream>  
11. using namespace std;  
12.   
13. void MinSubString( char *src, char *des )  
14. {  
15.     int min=1000;//找最短子串  
16.     int minfront=0;//最短子串开始位置  
17.     int minrear=0;//最短子串结束位置  
18.     int front,rear;  
19.     front=rear=0;  
20.     int len=strlen(des);  
21.     int hashtable[255]={0};  
22.     int cnt[255]={0};  
23.     int cnt2[255]={0};  
24.     for(int i=0; i<len; i++)//将字符集里的字符映射到hashtable数组中，方便判断src中的某个字符是否在字符集中  
25.         hashtable[*(des+i)]=1;  
26.     int count=0;  
27.     char *p=src;  
28.     while( *(p+rear) !=‘\0’)  
29.     {  
30.         if(hashtable[*(p+rear)]==1)//rear当前字符在字符集中  
31.         {  
32.             if(cnt2[*(p+rear)]==0)//判断是否是本子串中第一次检索到此字符，由count统计字符集中已出现的字符数  
33.             {  
34.                 count++;  
35.                 cnt[*(p+rear)]++;  
36.                 cnt2[*(p+rear)]++;  
37.                 if(count == len)//字符集中的字符在本子串中都已检索到  
38.                 {  
39.                     while(1)  
40.                     {  
41.                         if(hashtable[*(p+front)]==1)//front当前字符在字符集中  
42.                         {  
43.                             cnt[*(p+front)]–;  
44.                             if(cnt[*(p+front)]==0)//字符集中某个字符为0，此时front到rear所指字符串即为符合条件的子串  
45.                             {  
46.                                 for(i=front; i<=rear; i++)//打印此子串  
47.                                     cout<<*(p+i);  
48.                                 cout<<endl;  
49.                                 if(rear-front+1<min)  
50.                                 {  
51.                                     min=rear-front+1;  
52.                                     minrear=rear;  
53.                                     minfront=front;  
54.                                 }  
55.                                 //开始另一个串的检索时，要将count和cnt2[]清零。cnt[]不用变  
56.                                 count=0;  
57.                                 for(i=0; i<255; i++)  
58.                                     cnt2[i]=0;  
59.                                 front++;  
60.                                 break;                                
61.                             }                 
62.                         }  
63.                         front++;  
64.                     }  
65.                 }  
66.             }  
67.             else  
68.             {  
69.                 cnt[*(p+rear)]++;     
70.                 cnt2[*(p+rear)]++;    
71.             }  
72.         }//当前字符不在字符集中  
73.         rear++;  
74.     }  
75.   
76.   
77.     cout<<“最短子串：”;  
78.     for(i=minfront ; i<=minrear; i++)  
79.         cout<<*(p+i);  
80.     cout<<endl;  
81.   
82.   
83.   
84.   
85.   
86. }  
87.   
88. void main()  
89. {  
90.     char *src=“ab1dkj2ksjf3ae32ks1iji2sk1ksl3ab;iksaj1223”;  
91. //  char *src=”2sk1ksl3ab;iksaj1223″;  
92.     char *des=“123”;  
93.     MinSubString( src, des );  
94.   
95.   
96. }