PKU 3581 Sequence 解题报告

1. /*
2.   Title: Sequence
3.   Author: Jeff
4.   Time:  2008/10/29
5.   Complexity: O(N*log(N));
6.   Result: 7364K 1829MS/ AC
7.   Reference: 
8.         Discuss
9.   Description: 
10.         给定一个数组{A1, A2, …, An} 满足A1 > A2, …, An,
11.         把该数组分成三段，单独翻转，使得数组的字典序最小。
12.   Tips:
13.         后缀数组。 
14.         输入数据时候反序输入，再求后继数组。
15.         比如原始数据：
16.         6
17.         10 1 1 2 3 4
18.         反序输入就是
19.         4 3 2 1 1 10
20.         第一部分就是满足能将该序列分成三段的排在最前的后缀数。就是 1 1 10 了。
21.         去掉这一部分之后再求一次后缀数组，
22.         第二部分就是满足能将该序列分成两段的最大的后缀数。就是 2
23.         再输出最后一部分 4 3
24.         结果 1 1 10 2 4 3
25.         
26.         为什么要求两次后缀数组呢，看下面一组数据
27.         7
28.         5 0 2 1 2 1 3 
29.         (反序) 3 1 2 1 2 0 5
30.         按照第一次求后缀数组的结果：
31.         一：0 5
32.         二：1 2 (因为后缀1 2 0 5比1 2 1 2 0 5要小) 
33.         三：3 1 2 
34.         最后结果：0 5 1 2 3 1 2 (WA) 
35.         所以要去掉第一段结果再求一次后缀数组：
36.         (二三段反序) 3 1 2 1 2
37.         现在后缀1 2 1 2 比 1 2要小，所以得到正确结果： 
38.         二：1 2 1 2
39.         三：3
40.         最后结果：0 5 1 2 1 2 3 
41.         
42.   p.s. 
43.         只求一次后缀数组，结果WA掉了。。。 
44. */
45. #include <cstdio>
46. #include <cstring>
47. #include <algorithm>
49. using namespace std;
51. const int MAX = 200001;
53. struct Sfx{
54.     int idx;
55.     int key[2];
56.     bool operator<(const Sfx &other)const{
57.         return key[0] < other.key[0] || 
58.             key[0] == other.key[0] && key[1] < other.key[1];    
59.     }    
60. };
62. Sfx g_sfx[2][MAX], *sa = g_sfx[0], *temp_sa = g_sfx[1];
63. int cnt[MAX];
64. int rank[MAX];
65. int A[MAX];
66. int n;
68. void cSort(Sfx *in, int key, Sfx *out){
69.     memset(cnt, 0, sizeof(cnt));;
70.     for(int i = 0; i < n; i++)
71.         cnt[in[i].key[key]]++;
72.     for(int i = 1; i < n; i++)
73.         cnt[i] += cnt[i-1];
74.     for(int i = n - 1; i >= 0; i--)
75.         out[ --cnt[in[i].key[key]] ] = in[i];
76. }
78. void build_sfx(){
79.     for(int i = n-1; i >= 0; i--){
80.             sa[i].idx = sa[i].key[1] = i;
81.             sa[i].key[0] = A[i];
82.         }    
83.         sort(sa, sa+n);
84.         for(int i = 0; i < n; i++)sa[i].key[1] = 0;
85.         
86.         int wid = 1;
87.         
88.         while(wid < n){
89.             rank[sa[0].idx] = 0;
90.             for(int i = 1; i < n; i++){
91.                 rank[sa[i].idx] = rank[sa[i-1].idx];
92.                 if(sa[i-1] < sa[i])rank[sa[i].idx]++;
93.             }
94.             for(int i = 0; i < n; i++){
95.                 sa[i].idx = i;
96.                 sa[i].key[0] = rank[i];
97.                 sa[i].key[1] = i + wid < n ? rank[i + wid] : 0;    
98.             }
99.             cSort(sa, 1, temp_sa); cSort(temp_sa, 0, sa);
100.             wid *= 2;    
101.         }
102.         //printf("/n");for(int i = 0; i < n; i++)printf("%d ", A[i]);printf("/n");
103.         //printf("sa: ");for(int i = 0; i < n; i++)printf("%d ", sa[i].idx);printf("/n");
104.         //printf("r: ");for(int i = 0; i < n; i++)printf("%d ", rank[i]); printf("/n");
105. }
108. int main(){
109.     freopen("in.txt", "r", stdin);
110.     freopen("out.txt", "w", stdout);
111.     while(scanf("%d", &n) != EOF){
112.         for(int i = n-1; i >= 0; i--)
113.             scanf("%d", &A[i]);
114.         build_sfx();
115.         int ans[4];
116.         ans[0] = n;
117.         for(int i = 0, j = 1; j <= 1; i++){
118.             if(sa[i].idx < ans[j-1])
119.                 if(sa[i].idx >= 3 - j){
120.                     ans[j] = sa[i].idx;
121.                     for(int k = ans[j]; k < ans[j-1]; k++)
122.                         printf("%d/n", A[k]);
123.                     j++;    
124.                 }
125.         }
126.         n = ans[1];
127.         build_sfx();
128.         for(int i = 0, j = 2; j <= 2; i++){
129.             if(sa[i].idx < ans[j-1])
130.                 if(sa[i].idx >= 3 - j){
131.                     ans[j] = sa[i].idx;
132.                     for(int k = ans[j]; k < ans[j-1]; k++)
133.                         printf("%d/n", A[k]);
134.                     j++;    
135.                 }
136.         }
137.         for(int k = 0; k < ans[2]; k++)printf("%d/n", A[k]);
138.         break;
139.         //printf("/n");
140.     } 
141.     return 0;    
142. }