BZOJ 4212: 神牛的养成计划

4212: 神牛的养成计划

Time Limit: 10 Sec  Memory Limit: 512 MB
Submit: 142  Solved: 30
[Submit][Status][Discuss]

Description

Hzwer成功培育出神牛细胞，可最终培育出的生物体却让他大失所望......

 

后来，他从某同校女神 牛处知道，原来他培育的细胞发生了基因突变，原先决定神牛特征的基因序列都被破坏了，神牛hzwer很生气，但他知道基因突变的低频性，说不定还有以下优秀基因没有突变，那么他就可以用限制性核酸内切酶把它们切出来，然后再构建基因表达载体什么的，后面你懂的......

 

黄学长现在知道了N个细胞的DNA序列，它们是若干个由小写字母组成的字符串。一个优秀的基因是两个字符串s1和s2,当且仅当s1是某序列的前缀的同时，s2是这个序列的后缀时，hzwer认为这个序列拥有这个优秀基因。

 

现在黄学长知道了M个优秀基因s1和s2，它们想知道对于给定的优秀基因，有多少个细胞的DNA序列拥有它。

 

Input

第一行：N，表示序列数

接下来N行，每行一个字符串，代表N个DNA序列，它们的总长为L1

接下来一个M，表示询问数

接下来M行，每行两个字符串s1和s2，由一个空格隔开，hzwer希望你能在线回答询问，所以s1等于“s1”的所有字符按字母表的顺序向后移动ans位（字母表是一个环），ans为上一个询问的答案，s2同理。例如ans=2  “s1”=qz

则s1=sb。对于第一个询问，ans=0

s1和s2的总长度为L2

 

Output

输出M行，每行一个数，第i行的数表示有多少个序列拥有第i个优秀基因。

 

Sample Input

10
emikuqihgokuhsywlmqemihhpgijkxdukjfmlqlwrpzgwrwozkmlixyxniutssasrriafu
emikuqihgokuookbqaaoyiorpfdetaeduogebnolonaoehthfaypbeiutssasrriafu
emikuqihgokuorocifwwymkcyqevdtglszfzgycbgnpomvlzppwrigowekufjwiiaxniutssasrriafu
emikuqihgokuorociysgfkzpgnotajcfjctjqgjeeiheqrepbpakmlixyxniutssasrriafu
emikuqihgokuorociysgfrhulymdxsqirjrfbngwszuyibuixyxniutssasrriafu
emikuqihgokuorguowwiozcgjetmyokqdrqxzigohiutssasrriafu
emikuqihgokuorociysgsczejjmlbwhandxqwknutzgdmxtiutssasrriafu
emikuqihgokuorociysgvzfcdxdiwdztolopdnboxfvqzfzxtpecxcbrklvtyxniutssasrriafu
emikuqihgokuorocsbtlyuosppxuzkjafbhsayenxsdmkmlixyxniutssasrriafu
emikuqihgokuorociysgfjvaikktsixmhaasbvnsvmkntgmoygfxypktjxjdkliixyxniutssasrriafu
10
emikuqihgokuorociysg yxniutssasrriafu
aiegqmedckgqknky eqpoowonnewbq
xfbdnjbazhdnhkhvb qrqgbnmlltlkkbtyn
bjfhrnfedlhrlolzfv qppxpoofxcr
zhdfpldcbjf stsidponnvnmmdvap
zhdfpldcbjfpjmjxdt gdstsidponnvnmmdvap
dlhjtphgfnjtnqnbhxr wxwmhtsrrzrqqhzet
bjfhrnfedlhrlolzfv frqppxpoofxcr
zhdfpldcbjf dponnvnmmdvap
ucyakgyxweakehes nondykjiiqihhyqvk

Sample Output

4
7
3
5
5
1
3
5
10
4

HINT

N<=2000

L1<=2000000

M<=100000

L2<=2000000

Source

 

[Submit][Status][Discuss]

万古神牛黄学长 Orz

又是一道可持久化Trie好题。

先想暴力，每次先找出有所能匹配上前缀的串，然后在看看这些串里有多少个还能匹配上后缀，这些串的个数就是最终答案。

然后发现，每次靠前缀筛出来的所有串一定具有一段相同的前缀，这个有点像后缀数组的那种感觉，就是先对所有串按照前缀排序，不难看出每次找出的前缀合法的串一定排成一个区间，我们想访问这个区间的所有串的逆序Trie，这个就是可持久化Trie树了。

从DaD3zZ那里看到这道题的，他说感觉对串按照前缀排序时使用了C++的Sort函数，逐位比较两个串的大小貌似比较暴力；但是不难想到，我们先建出正序的Trie后，在Trie上按顺序（a->z）DFS出来的就是按前缀排好序的了，这样复杂度就是完美的$O(\sum{Length})$，轻松过掉2000000。貌似出题人比较友好（可能就是比较懒），出的数据有点水……

代码没有，懒得写了…… 懒癌晚期

UPDATE 写了一发代码，然后图省事用的string，然后cin就给RE了，下午发现问题改成scanf就可以了。

 #include <bits/stdc++.h>

 using namespace std;

 const int mxn = ;
 const int mxm = ;

 inline void scan(string &s)
 {
     s.clear();

     static char buf[mxm];

     scanf("%s", buf);

     for (char *c = buf; *c; ++c)
         s.push_back(*c);
 }

 int n, m;

 int ord[mxn];

 string str[mxn];

 int end[mxm];
 int son[mxm][];

 int mini[mxm];
 int maxi[mxm];

 inline void insert(string &s, int id) {
     static int tot = ;

     int p = , len = s.length();

     for (int i = ; i < len; ++i) {
         if (son[p][s[i] - 'a'] == )
             son[p][s[i] - 'a'] = ++tot;

         p = son[p][s[i] - 'a'];
     }

     end[p] = id;
 }

 void getOrder(int p) {
     static int cnt;

     mini[p] = cnt;

     if (end[p])
         ord[++cnt] = end[p];

     for (int i = ; i < ; ++i)
         if (son[p][i])getOrder(son[p][i]);

     maxi[p] = cnt;
 }

 int root[mxn];

 int sum[mxm];
 int nxt[mxm][];

 void insert(int &t, int p, string &s, int d) {
     static int tot = ;

     t = ++tot;

     sum[t] = sum[p] + ;

     memcpy(nxt[t], nxt[p], sizeof(nxt[t]));

     if (d < s.length())
         insert(nxt[t][s[d] - 'a'], nxt[p][s[d] - 'a'], s, d + );
 }

 inline void trie1(string &s, int &lt, int &rt, int ans) {
     int p = , len = s.length();

     for (int i = ; i < len; ++i)
         s[i] = (s[i] - 'a' + ans) %  + 'a';

     lt = rt = ;

     for (int i = ; i < len; ++i)
         p = son[p][s[i] - 'a'];

     lt = mini[p];
     rt = maxi[p];
 }

 inline void trie2(string &s, int lt, int rt, int &ans) {
     int len = s.length();

     reverse(s.begin(), s.end());

     for (int i = ; i < len; ++i)
         s[i] = (s[i] - 'a' + ans) %  + 'a';

     int a = root[lt], b = root[rt];

     for (int i = ; i < len; ++i) {
         a = nxt[a][s[i] - 'a'];
         b = nxt[b][s[i] - 'a'];
     }

     ans = sum[b] - sum[a];
 }

 signed main(void) {
 #ifndef ONLINE_JUDGE
     freopen("in", "r", stdin);
     freopen("out", "w", stdout);
 #endif

     scanf("%d", &n);

     for (int i = ; i <= n; ++i)
         scan(str[i]);

     for (int i = ; i <= n; ++i)
         insert(str[i], i);

     getOrder();

     for (int i = ; i <= n; ++i)
         reverse(str[i].begin(), str[i].end());

     for (int i = ; i <= n; ++i)
         insert(root[i], root[i - ], str[ord[i]], );

     scanf("%d", &m);

     for (int i = , lt, rt, ans = ; i <= m; ++i) {
         static string s1, s2;

         scan(s1);
         scan(s2);

         trie1(s1, lt, rt, ans);
         trie2(s2, lt, rt, ans);

         printf("%d\n", ans);
     }
 }

@Author: YouSiki