【理解字符串循环同构的最小表示法】

【理解字符串循环同构的最小表示法】

分类：  ACM/ICPC2010-04-09 16:35  1504人阅读  评论(0)  收藏  举报

算法 优化 语言 工作

循环字符串的最小表示法的问题可以这样描述：

对于一个字符串S，求S的循环的同构字符串S’中字典序最小的一个。

由于语言能力有限，还是用实际例子来解释比较容易：
设S=bcad，且S’是S的循环同构的串。S’可以是bcad或者cadb,adbc,dbca。而且最小表示的S’是adbc。
对于字符串循环同构的最小表示法，其问题实质是求S串的一个位置，从这个位置开始循环输出S，得到的S’字典序最小。
一种朴素的方法是设计i,j两个指针。其中i指向最小表示的位置，j作为比较指针。

令i=0,j=1
如果S[i] > S[j] i=j, j=i+1
如果S[i] < S[j] j++
如果S[i]==S[j] 设指针k，分别从i和j位置向下比较，直到S[i] != S[j]
         如果S[i+k] > S[j+k] i=j,j=i+1
         否则j++
返回i

起初，我想在j指针后移的过程中加入一个优化。就是j每次不是加1，而是移动到l位置。其中，l>j且S[l]<=S[j]。但是，即使加入这一优化，在遇到bbb…bbbbbba这样的字符串时复杂度将退化到O(n^2)。

注意到，朴素算法的缺陷在于斜体的情况下i指针的移动太少了。针对这一问题改进就得到了最小表示法的算法。最小表示法的算法思路是维护两个指针i,j。

令i=0,j=1
如果S[i] > S[j] i=j, j=i+1
如果S[i] < S[j] j++
如果S[i]==S[j] 设指针k，分别从i和j位置向下比较，直到S[i] != S[j]
         如果S[i+k] > S[j+k] i=i+k
         否则j++
返回i和j的小者

注意到上面两个算法唯一的区别是粗体的一行。这一行就把复杂度降到O(n)了。
值得一提的是，与KMP类似，最小表示法处理的是一个字符串S的性质，而不是看论文时给人感觉的处理两个字符串。
应用最小表示法判断两个字符串同构，只要将两个串的最小表示求出来，然后从最小表示开始比较。剩下的工作就不用多说了。

[cpp]  view plain copy

1. int MinimumRepresentation(char *s, int l)  
2. {  
3.     int i = 0, j = 1, k = 0, t;  
4.     while(i < l && j < l && k < l) {  
5.         t = s[(i + k) >= l ? i + k - l : i + k] - s[(j + k) >= l ? j + k - l : j + k];  
6.         if(!t) k++;  
7.         else{  
8.             if(t > 0) i = i + k + 1;  
9.             else j = j + k + 1;  
10.             if(i == j) ++ j;  
11.             k = 0;  
12.         }  
13.     }  
14.     return (i < j ? i : j);  
15. } 

 

【字符串最小(大)表示法+KMP求循环节】hdoj 3374 String Problem

分类： ACM/ICPC 2010-04-09 18:24  692人阅读  评论(0)  收藏  举报

string output input each

首先用 字符串最小(大)表示法 解决第一个问题

然后用 KMP求循环节 解决第二个问题

 

 #include <cstdio>
 #include <cstring>
 #define NUM 1000005

 void getnext(char str[],int next[])
 {
     next[0] = -1;
     int i=0;
     int j=-1;
     int len = strlen(str);
     while (i<len)
     {
         if (j==-1||str[i]==str[j])
         {
             i++;
             j++;
             next[i] = j;
         } else {
             j=next[j];
         }
     }
 }

 int MinAndMaxRepresentation(char *s, bool bMin = true)
 {
     int i = 0, j = 1, k = 0, l = strlen(s), sub;
     while (i<l && j<l && k<l)
     {
         sub = s[(i+k)%l] -  s[(j+k)%l];
         if (sub == 0)
             k++;
         else
         {
             if (bMin?sub > 0:sub < 0)
                 i += k+1;
             else
                 j += k+1;
             if (i == j)
                 j++;
             k = 0;
         }
     }
     return i<j?i:j;
 }
 char str[NUM];
 int next[NUM];
 int main()
 {
     int len;
     int minlen;
     int num;
     while (scanf("%s", str) != EOF)
     {
         len = strlen(str);
         getnext(str, next);
         if (len % (len-next[len]) == 0)
             minlen = len-next[len];
         else
             minlen = len;
         num = len / minlen;
         //printf("%d/n", minlen);
         printf("%d %d %d %d/n", MinAndMaxRepresentation(str)+1, num, MinAndMaxRepresentation(str, false)+1, num);
     }
     return 0;
 }
 /*
 String Problem
 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
 Total Submission(s): 290    Accepted Submission(s): 110


 Problem Description
 Give you a string with length N, you can generate N strings by left shifts. For example let consider the string “SKYLONG”, we can generate seven strings:
 String Rank
 SKYLONG 1
 KYLONGS 2
 YLONGSK 3
 LONGSKY 4
 ONGSKYL 5
 NGSKYLO 6
 GSKYLON 7
 and lexicographically first of them is GSKYLON, lexicographically last is YLONGSK, both of them appear only once.
 Your task is easy, calculate the lexicographically fisrt string’s Rank (if there are multiple answers, choose the smallest one), its times, lexicographically last string’s Rank (if there are multiple answers, choose the smallest one), and its times also.



   Input
   Each line contains one line the string S with length N (N <= 1000000) formed by lower case letters.


   Output
   Output four integers separated by one space, lexicographically fisrt string’s Rank (if there are multiple answers, choose the smallest one), the string’s times in the N generated strings, lexicographically last string’s Rank (if there are multiple answers, choose the smallest one), and its times also.


   Sample Input
   abcder
   aaaaaa
   ababab


   Sample Output
   1 1 6 1
   1 6 1 6
   1 3 2 3
 */