一個01字符串，求出現0、1出現次數相等的最長子串

題目描述：

     已知一個長度為N的字符串，只由0和1組成， 求一個最長的子串，要求該子串出0和1出現的次數相等。

     要求算法時間復雜度盡可能的低。

     比如：  1000010111000001，加粗的部分有4個0、4個1  

 

思路：

(1) 最簡單的想法就是遍歷所有的子串，之后判斷該子串是否滿足條件

     N^2子串，每個子串掃一遍判斷0、1是否出現的次數相等，復雜度為O(N^3)

     稍加思考就會發現， 如果一個長度為n的子串滿足條件，加么這n個元素的和 加起來一定=(n/2) 

     這樣在循環的過程中，增量加就可以了，不需要每個子串從頭計算，復雜度降為O(N^2);

     偽碼：

     輸入 A[N]

 

 
           
           int maxlen =  
           0, sum =  
           0, currlen =  
           0; 
           
 
           for( 
           int i =  
           0; i < N; ++i) 
           
{ 
           
    sum =  
           0; 
           
     
           for( 
           int j = i; j < N; ++j) 
           
    { 
           
        currlen = j - i +  
           1; 
           
        sum +=  
           int(A[j]); 
           
         
           if(currlen% 
           2 ==  
           0 && sum == currlen/ 
           2 && currlen > maxlen) 
           
            maxlen = currlen; 
           
    } 
           
         

 

 (2) 還有沒有辦法進一步降低算法的復雜度呢？

      問了一下姚神，得到了這樣一種巧妙的解法：定義一個數據B[N]， B[i]表示從A[0...i]中 num_of_0 - num_of_1，0的個數與1的個數的差

      那么如果A[i] ~ A[j]是符合條件的子串，一定有 B[i] == B[j]，因為中間的部分0、1個數相等，相減等於0。 只需要掃一遍A[N]就能把B[N]構造出來了。

      這樣問題就轉換成了求 距離最遠的一對數，使得B[i] == B[j]，因為B[i]的范圍一定是[-N,N]，-N到N的范圍都存起來，這樣每掃到B[i]，查數就行了。

      其實代碼真的非常簡單，一個循環就搞定了，這就是算法和思考的樂趣:) 

 
           
           int A[N],B[N]; 
           
 
           int num[ 
           2*N +  
           1]; 
           
 
           int count[ 
           2] = { 
           0, 
           0}, maxlen =  
           0, currlen =  
           0; 
           
memset(C,  
           2*N, - 
           1); 
           
 
           for( 
           int i =  
           0; i < N; ++i) 
           
{ 
           
   count[  
           int(A[i]) ] +=  
           1; 
           
   B[i] = count[ 
           1] - count[ 
           0]; 
           
    
           if( num[ B[i] + N ] == - 
           1) 
           // 
           尚不存在，B的下標是差，值是A的下標  
           
       num[ B[i] + N ] = i;  
           
    
           else 
           // 
           already exist 
           
   { 
           
       currlen = i - num[ B[i] + N ] +  
           1;  
           // 
           num[ B[i] + N ]是B[i]已存在的下標 
           
        
           if(currlen > maxlen) 
           
           maxlen = currlen; 
           
   } 
           
         

 

轉載請注明原文地址：http://www.cnblogs.com/worldisimple/archive/2012/04/13/2445051.html