最长不重复子串

文章作者：Yx.Ac   文章来源：勇幸|Thinking (http://www.ahathinking.com)

题：从一个字符串中找到一个连续子串，该子串中任何两个字符不能相同，求子串的最大长度并输出一条最长不重复子串。

本节从最直接的方法逐步优化，渐进探索了四种实现方式，并最终找到时间复杂度为O(N)，辅助空间为常数的方案，内容如下：

==基本算法 使用Hash==

==DP方案==

==DP + Hash 方案==

==DP + Hash 优化方案==

==================================

基本算法 使用Hash

要求子串中的字符不能重复，判重问题首先想到的就是hash，寻找满足要求的子串，最直接的方法就是遍历每个字符起始的子串，辅助hash，寻求最长的不重复子串，由于要遍历每个子串故复杂度为O(n^2)，n为字符串的长度，辅助的空间为常数hash[256]。代码如下：

[cpp] view plain copy

 print?

1. /* 最长不重复子串 设串不超过30 
2.  * 我们记为 LNRS 
3.  */  
4. int maxlen;  
5. int maxindex;  
6. void output(char * arr);  
7.    
8. /* LNRS 基本算法 hash */  
9. char visit[256];  
10.    
11. void LNRS_hash(char * arr, int size)  
12. {  
13.     int i, j;  
14.     for(i = 0; i < size; ++i)  
15.     {  
16.         memset(visit,0,sizeof visit);  
17.         visit[arr[i]] = 1;  
18.         for(j = i+1; j < size; ++j)  
19.         {  
20.             if(visit[arr[j]] == 0)  
21.             {  
22.                 visit[arr[j]] = 1;  
23.             }else  
24.             {  
25.                 if(j-i > maxlen)  
26.                 {  
27.                     maxlen = j - i;  
28.                     maxindex = i;  
29.                 }  
30.                 break;  
31.             }  
32.         }  
33.         if((j == size) && (j-i > maxlen))  
34.         {  
35.             maxlen = j - i;  
36.             maxindex = i;  
37.         }  
38.     }  
39.     output(arr);  
40. }  

==================================

DP方案

前面刚刚讨论过最长递增子序列的问题，咋一想就觉得二者有点类似，何不向DP方面想一下，为什么说二者类似，在LIS问题中，对于当前的元素，要么是与前面的LIS构成新的最长递增子序列，要么就是与前面稍短的子序列构成新的子序列或单独构成新子序列；

同理，对于最长不重复子串，某个当前的字符，如果它与前面的最长不重复子串中的字符没有重复，那么就可以以它为结尾构成新的最长子串；如果有重复，且重复位置在上一个最长子串起始位置之后，那么就与该起始位置之后的稍短的子串构成新的子串或者单独成一个新子串。

举个例子：例如字符串“abcdeab”，第二个字符a之前的最长不重复子串是“abcde”，a与最长子串中的字符有重复，但是它与稍短的“bcde”串没有重复，于是它可以与其构成一个新的子串，之前的最长重复子串“abcde”结束；

再看一个例子：字符串“abcb”，跟前面类似，最长串“abc”结束，第二个字符b与稍短的串“c”构成新的串；

这两个例子，可以看出些眉目：当一个最长子串结束时（即遇到重复的字符），新的子串的长度是与第一个重复的字符的下标有关的，如果该下标在上一个最长子串起始位置之前，则dp[i] = dp[i-1] + 1，即上一个最长子串的起始位置也是当前最长子串的起始位置；如果该下标在上一个最长子串起始位置之后，则新的子串是从该下标之后开始的。

于是类似LIS，对于每个当前的元素，我们“回头”去查询是否有与之重复的，如没有，则最长不重复子串长度+1，如有，则考察上一个子串起始位置与重复字符下标的关系，当然，如果DP使用O(n^2)的方案，则我们只需在内层循环遍历到上一个最长子串的起始位置即可，如下。

O(N^2)的DP方案，我们可以与LIS的DP方案进行对比，是一个道理的。代码如下：

[cpp] view plain copy

 print?

1. /* LNRS dp */  
2. int dp[30];  
3.    
4. void LNRS_dp(char * arr, int size)  
5. {  
6.     int i, j;  
7.     int last_start = 0;     // 上一次最长子串的起始位置  
8.     maxlen = maxindex = 0;  
9.    
10.     dp[0] = 1;  
11.     for(i = 1; i < size; ++i)  
12.     {  
13.         for(j = i-1; j >= last_start; --j) // 遍历到上一次最长子串起始位置  
14.         {  
15.             if(arr[j] == arr[i])  
16.             {  
17.                 dp[i] = i - j;  
18.                 last_start = j+1; // 更新last_start  
19.                 break;  
20.             }else if(j == last_start) // 无重复  
21.             {  
22.                 dp[i] = dp[i-1] + 1;  
23.             }  
24.         }  
25.         if(dp[i] > maxlen)  
26.         {  
27.             maxlen = dp[i];  
28.             maxindex = i + 1 - maxlen;  
29.         }  
30.     }  
31.     output(arr);  
32. }  

==================================

DP + Hash 方案

上面的DP方案是O(n^2)的，之所以是n^2，是因为“回头”去寻找重复元素的位置了，受启发于最初的Hash思路，我们可以用hash记录元素是否出现过，我们当然也可以用hash记录元素出现过的下标，既然这样，在DP方案中，我们何不hash记录重复元素的位置，这样就不必“回头”了，而时间复杂度必然降为O(N)，只不过需要一个辅助的常数空间visit[256]，典型的空间换时间。

代码如下：这样遍历一遍便可以找到最长不重复子串

[cpp] view plain copy

 print?

1. /* LNRS dp + hash 记录下标 */  
2. void LNRS_dp_hash(char * arr, int size)  
3. {  
4.     memset(visit, -1, sizeof visit);  
5.     memset(dp, 0, sizeof dp);  
6.     maxlen = maxindex = 0;  
7.     dp[0] = 1;  
8.     visit[arr[0]] = 0;  
9.     int last_start = 0;  
10.    
11.     for(int i = 1; i < size; ++i)  
12.     {  
13.         if(visit[arr[i]] == -1)  
14.         {  
15.             dp[i] = dp[i-1] + 1;  
16.             visit[arr[i]] = i; /* 记录字符下标 */  
17.         }else  
18.         {  
19.             if(last_start <= visit[arr[i]])  
20.             {  
21.                 dp[i] = i - visit[arr[i]];  
22.                 last_start = visit[arr[i]] + 1;  
23.                 visit[arr[i]] = i; /* 更新最近重复位置 */  
24.             }else  
25.             {  
26.                 dp[i] = dp[i-1] + 1;  
27.                 visit[arr[i]] = i; /* 更新最近重复位置 */  
28.             }  
29.    
30.         }  
31.         if(dp[i] > maxlen)  
32.         {  
33.             maxlen = dp[i];  
34.             maxindex = i + 1 - maxlen;  
35.         }  
36.     }  
37.     output(arr);  
38. }  

==================================

DP + Hash 优化方案

写到这里，还是有些别扭，因为辅助的空间多了，是不是还能优化，仔细看DP最优子问题解的更新方程：

[cpp] view plain copy

 print?

1. dp[i] = dp[i-1] + 1;  

dp[i-1]不就是更新dp[i]当前的最优解么？这与最大子数组和问题的优化几乎同出一辙，我们不需要O(n)的辅助空间去存储子问题的最优解，而只需O(1)的空间就可以了，至此，我们找到了时间复杂度O(N)，辅助空间为O(1)（一个额外变量与256大小的散列表）的算法，代码如下：

注意：当前最长子串的构成是与上一次最长子串相关的，故要记录上一次最长子串的起始位置！

[cpp] view plain copy

 print?

1. /* LNRS dp + hash 优化 */  
2. void LNRS_dp_hash_impro(char * arr, int size)  
3. {  
4.     memset(visit, -1, sizeof visit);  
5.     maxlen = maxindex = 0;  
6.     visit[arr[0]] = 0;  
7.     int curlen = 1;  
8.     int last_start = 0;  
9.    
10.     for(int i = 1; i < size; ++i)  
11.     {  
12.         if(visit[arr[i]] == -1)  
13.         {  
14.             ++curlen;  
15.             visit[arr[i]] = i; /* 记录字符下标 */  
16.         }else  
17.         {  
18.             if(last_start <= visit[arr[i]])  
19.             {  
20.                 curlen = i - visit[arr[i]];  
21.                 last_start = visit[arr[i]] + 1;  
22.                 visit[arr[i]] = i; /* 更新最近重复位置 */  
23.             }else  
24.             {  
25.                 ++curlen;  
26.                 visit[arr[i]] = i; /* 更新最近重复位置 */  
27.             }  
28.         }  
29.         if(curlen > maxlen)  
30.         {  
31.             maxlen = curlen;  
32.             maxindex = i + 1 - maxlen;  
33.         }  
34.     }  
35.     output(arr);  
36. }  

最后给出输出函数与测试用例：

[cpp] view plain copy

 print?

1. /* 输出LNRS */  
2. void output(char * arr)  
3. {  
4.     if(maxlen == 0)  
5.     {  
6.         printf("NO LNRS\n");  
7.     }  
8.     printf("The len of LNRS is %d\n",maxlen);  
9.    
10.     int i = maxindex;  
11.     while(maxlen--)  
12.     {  
13.         printf("%c",arr[i++]);  
14.     }  
15.     printf("\n");  
16. }  
17.    
18. void main()  
19. {  
20.      char arr[] = "abcaacdeabacdefg";  
21.    
22.      /* LNRS 基本算法 */  
23.      LNRS_hash(arr,strlen(arr));  
24.    
25.      /* LNRS dp */  
26.      LNRS_dp(arr,strlen(arr));  
27.    
28.      /* LNRS dp + hash 记录下标 */  
29.      LNRS_dp_hash(arr,strlen(arr));  
30.    
31.      /* LNRS dp + hash 优化方案 */  
32.      LNRS_dp_hash_impro(arr,strlen(arr));  
33. }