Uva 12361 File Retrieval 后缀数组+并查集

题意：有F个单词,1 <= F <=60 , 长度<=10^4, 每次可以输入一个字符串，所有包含该字串的单词会形成一个集合。

问最多能形成多少个不同的集合。集合不能为空。

分析：用后缀数组处理。然后首先考虑一个单词形成一个集合的情况，若该单词是其他单词的字串，则该单词显然不会形成一个集合，那么利用后缀数组，

对于每个单词看能否与其他单词有LCP，且LCP 长度为该单词本身长度。

然后就是多个单词形成集合的情况：比较简单的处理方式就是将h数组值相同的下标集中存储，比如h[x] = h[y] = h[z] = 5, 那么将x，y，z存到h

值对应为5的数组中，然后按照h值，假设为v，从大到小的顺序，将所有h值为v的下标与其周围的LCP大于v的（h[v-1],h[v]）对应的子串，更新并查集。实际意义就是，每次将h值为h[v]的一些子串所在的单词合并到之前h值> h[v]的子串所在的单词形成的并查集中，得到的并查集中单词一定有长度>=h[v]公共字串，这样的并查集实际就是一个合法的单词集合，可以利用二进制表示，每次得到新的集合则将二进制表示加入到统计集合的set中，最后结果就是set的大小。

AC代码其实是比赛时写的，当时多个单词部分不是上面这种写法，不过类似。

 #include <bits/stdc++.h>
 #define  in  freopen("solve_in.txt", "r", stdin);
 #define  bug(x)  printf("Line %d:>>>>>>>\n", (x));

 #define  REV(a)    reverse((a).begin(), (a).end())
 #define  READ(a, n) {REP(i, n) cin>>(a)[i];}
 #define  REP(i, n) for(int i = 0; i < (n); i++)
 #define  VREP(i, n, base) for(int i = (n); i >= (base); i--)
 #define  Rep(i, base, n) for(int i = (base); i < (n); i++)
 #define  REPS(s, i) for(int i = 0; (s)[i]; i++)
 using namespace std;
 typedef unsigned long long ULL;
 typedef long long LL;
 typedef map<ULL, int> UMps;
 set<ULL> se;

 const int maxn =  + ;
 const int maxm = ;
 const int maxlen = maxn*maxm+;
 int s[maxlen];
 int sa[maxlen], t[maxlen], t2[maxlen], c[maxlen], n, m, dp[maxlen][];
 int num[maxlen];
 LL ans;
 void build_sa(int m) {
     int *x = t, *y = t2;

     REP(i, m) c[i] = ;
     REP(i, n) c[x[i] = s[i]]++;
     Rep(i, , m) c[i] += c[i-];
     VREP(i, n-, ) sa[--c[x[i]]] = i;

     for(int k = ; k <= n; k <<= ) {
         int p = ;

         Rep(i, n-k, n) y[p++] = i;
         REP(i, n) if(sa[i] >= k) y[p++] = sa[i]-k;

         REP(i, m) c[i] = ;
         REP(i, n) c[x[y[i]]]++;
         Rep(i, , m) c[i] += c[i-];

         VREP(i, n-, ) sa[--c[x[y[i]]]] = y[i];
         swap(x, y);
         p = , x[sa[]] = ;
         Rep(i, , n)
         x[sa[i]] = y[sa[i-]] == y[sa[i]] && y[sa[i-]+k] == y[sa[i]+k] ? p- : p++;
         if(p >= n) break;
         m = p;
     }
 }
 int rk[maxlen], h[maxlen];

 void getHeight() {
     int j, k = ;
     h[] = ;
     REP(i, n) rk[sa[i]] = i;
     REP(i, n) {
         if(k) k--;
         if(rk[i] == )
             continue;
         j = sa[rk[i]-];
         while( s[i+k] == s[j+k]) k++;
         h[rk[i]] = k;
     }
 }
 void RMQ_init() {
     REP(i, n) dp[i][] = h[i];
     for(int k = ; (<<k) <= n; k++)
         for(int i = ; i + (<<k) <= n; i++)
             dp[i][k] = min(dp[i][k-], dp[i+(<<(k-))][k-]);
 }
 int RMQ(int l, int r) {
     int k = ;
     while((<<(k+)) <= r-l+) k++;
     return min(dp[l][k], dp[r-(<<k)+][k]);
 }
 char word[maxm][maxn];
 int nn;
 inline int idx(char ch) {
     return ch-'a'+;
 }
 int vis[], slen[];

 void solveSingle() {
     se.clear();
     memset(vis, , sizeof vis);
     for(int i = ; i < n; i++){
         if(h[i]){
             if(num[sa[i]] != - && h[i] == slen[num[sa[i]]])
                 vis[num[sa[i]]] = ;
             if(num[sa[i-]] != - && h[i] == slen[num[sa[i-]]])
                 vis[num[sa[i-]]] = ;
         }
     }
     for(int i = ; i < nn; i++) if(!vis[i])
             se.insert(1ULL<<i);
 }
 void dfs(int l, int r, int now) {
     if(l >= r)
         return;
     ULL tmp;

     for(int i = l; i < r; ) {
         tmp = ;
         while(i < r && h[i] <= now)
             i++;
         if(i >= r)
             break;
         int mx = (int)1e9;
         int j = i;
         mx = min(mx, h[j]);
         if(j < r && num[sa[j-]] != -)
             tmp |= 1ULL<<num[sa[j-]];
         while(j < r && h[j] > now) {
             mx = min(mx, h[j]);
             if(num[sa[j]] != -)
                 tmp |= 1ULL<<num[sa[j]];
             j++;
         }
         if(tmp)
         se.insert(tmp);
         dfs(i, j, mx);
         i = j;
     }
 }
 void solve() {
     build_sa();
     getHeight();
     solveSingle();
     ULL tmp;
     for(int i = ; i < n; ) {
         int mx = (int)1e9;
         tmp = ;
         while(i < n && !h[i])
             i++;
         if(i >= n)
             break;
         mx = min(mx, h[i]);
         int j = i;
         if(j < n && num[sa[j-]] != -)
             tmp |= 1ULL<<num[sa[j-]];
         while(j < n && h[j]) {
             mx = min(mx, h[j]);
             if(num[sa[j]] != -)
                 tmp |= 1ULL<<num[sa[j]];
             j++;
         }
         if(tmp)
         se.insert(tmp);
         dfs(i, j, mx);
         i = j;
     }
     printf("%llu\n", (ULL)se.size());
 }
 int main() {

     while(scanf("%d", &nn), nn) {
         n = ;
         memset(num, -, sizeof num);
         for(int i = ; i < nn; i++) {
             slen[i] = ;
             scanf("%s", word[i]);
             for(int j = ; word[i][j]; j++) {
                 slen[i]++;
                 s[n] = idx(word[i][j]);
                 num[n++] = i;
             }
             s[n++] = +i;
         }
         s[n-] = ;
         solve();
     }
     return ;
 }