Favorite Donut

Favorite Donut

Time Limit: 1500/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 1378    Accepted Submission(s): 356

Problem Description

Lulu has a sweet tooth. Her favorite food is ring donut. Everyday she buys a ring donut from the same bakery. A ring donut is consists of n parts. Every part has its own sugariness that can be expressed by a letter from a to z (from low to high), and a ring donut can be expressed by a string whose i-th character represents the sugariness of the i−th part in clockwise order. Note that z is the sweetest, and two parts are equally sweet if they have the same sugariness.

Once Lulu eats a part of the donut, she must continue to eat its uneaten adjacent part until all parts are eaten. Therefore, she has to eat either clockwise or counter-clockwise after her first bite, and there are 2n ways to eat the ring donut of n parts. For example, Lulu has 6 ways to eat a ring donut abc: abc,bca,cab,acb,bac,cba. Lulu likes eating the sweetest part first, so she actually prefer the way of the greatest lexicographic order. If there are two or more lexicographic maxima, then she will prefer the way whose starting part has the minimum index in clockwise order. If two ways start at the same part, then she will prefer eating the donut in clockwise order. Please compute the way to eat the donut she likes most.

 

Input

First line contain one integer T,T≤20, which means the number of test case.

For each test case, the first line contains one integer n,n≤20000, which represents how many parts the ring donut has. The next line contains a string consisted of n lowercase alphabets representing the ring donut.

 

Output

You should print one line for each test case, consisted of two integers, which represents the starting point (from 1 to n) and the direction (0 for clockwise and 1 for counterclockwise).

 

Sample Input

2

4

abab

4

aaab

 

Sample Output

2 0

4 0

 

Source

2015 ACM/ICPC Asia Regional Changchun Online

题意：Lulu喜欢吃炸面圈，炸面圈有n个部分组成，每个部分由小写字母代表其甜度，Lulu总是从最甜的开始吃，两个方向，哪个最甜吃哪个。输出满足她要求吃法的最开始的下标，和方向。最大最小表示法

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<algorithm>
 
 using namespace std;
 
 #define maxn 40008
 
 int n, Next[maxn];
 
 void Getnext(char s[], int n)   // kmp获得Next数组，next会出现编译错误，我也不造为什么……
 {
     int j, k;
     j = ;
     k = Next[] = -;
     while(j < n)
     {
         if(k == - || s[j] == s[k])
 
          Next[++j] = ++k;
         else
             k = Next[k];
     }
 }
 
 int GETNEXT(char s[], int n)  // 找下标最小的开始的串满足吃法
 {
     int i, j;
     i = ;
     j = ;
     while(i < n && j < n)   // i, j比较，每次让相对字典序小的改变，最后肯定有一个超过n，那个没超过n的就是满足题意的
     {
         int k = ;
         while( s[i+k] == s[j+k] && k < n)  // 如果这两个下标对应的字典序相等，继续向下比较，知道不等为止
             k++;
         if(k == n)
             break;
         if(s[i+k] > s[j+k])
         {
             if(j+k > i)
                 j = j + k + ;
             else
                 j = i + ;
         }
         else
         {
             if(i+k > j)
                 i = i + k + ;
             else
                 i = j + ;
         }
     }
     return min(i, j);
 }
 
 int KMP(char s[], char s1[], int n, int m)   //在逆串中找开始下标最后边的满足题意的串（就是下标最小的，next， kmp优化
 {
     int i, j, ans;
     i = j = ;
     while(j < m)
     {
         while( i == - || (s[i] == s1[j] && j < m))
             i++, j++;
 
         if(i == n)
             ans = j - n;
         i = Next[i];
     }
     return ans;
 }
 
 int main()
 {
     int c;
     scanf("%d", &c);
     char s[maxn], s1[maxn], s2[maxn], s3[maxn], s4[maxn];
 
     while(c--)
     {
         memset(s, , sizeof(s));
         memset(s1, , sizeof(s1));
         memset(s2, , sizeof(s2));
         memset(s3, , sizeof(s3));
         memset(s4, , sizeof(s4));
 
         scanf("%d", &n);
         scanf("%s", s);
         strcpy(s1, s);
         strcat(s1, s);
 
         int a = GETNEXT(s1, n);  // 找到正序的满足题意的下标
         strncpy(s3, s1+a, n);   // 把满足题意的s3中
 
         strrev(s);
         strcpy(s2, s);
         strcat(s2, s);
         int b = GETNEXT(s2, n);  // 找逆串中的满足题意的下标
         strncpy(s4, s2+b, n);
 
         Getnext(s4, n);
         b = KMP(s4, s2, n, *n-);   // 找逆串中满足题意的最后边的下标，也就是正串中最前边的下标……
         strncpy(s4, s2+b, n);
 
         int g = strcmp(s3, s4);
 
         if(g == )
         {
             if(a+ <= n-b)
                 printf("%d 0\n", a+);
             else
                 printf("%d 1\n", n-b);
         }
         else if(g > )
             printf("%d 0\n", a+);
         else
             printf("%d 1\n", n-b);
     }
     return ;
 }
 /*
 4
 
 4
 aaab
 4
 abca
 6
 abcabc
 4
 abab
 */

你已经得到最大表示法的下标时，你也可以这么取满足该串的最小下标……

求逆串的最大最小表示法的“最小下标的时候可以用最小循环节做

 int solve (char* s){
     getNext(s);
     if (n % (n - Next[n]))
         return n;
     else
         return n - Next[n];
 }
 int b=Getmin(s);
 int k=solve(s);
 b = (n - b - ) % k; // 获得最小的……最小循环节是个神奇的东西……