HDU 5469 Antonidas

Antonidas

Time Limit: 4000ms

Memory Limit: 65536KB

This problem will be judged on HDU. Original ID: 5469
64-bit integer IO format: %I64d      Java class name: Main

 

Given a tree with N vertices and N−1 edges. Each vertex has a single letter Ci. Given a string S, you are to choose two vertices A and B, and make sure the letters catenated on the shortest path from A to B is exactly S. Now, would you mind telling me whether the path exists?

Input
The first line is an integer T, the number of test cases.
For each case, the first line is an integer N. Following N−1 lines contains two integers a and b, meaning there is an edge connect vertex a and vertex b.
Next line contains a string C, the length of C is exactly N. String C represents the letter on each vertex.
Next line contains a string S.
$1\leq T\leq 200, 1\leq N\leq 10^4, 1\leq a,b\leq N, a\not = b, |C|=N, 1\leq |S|\leq 10^4$. String C and S both only contain lower case letters.

Output
First, please output "Case #k: ", k is the number of test case. See sample output for more detail.
If the path exists, please output “Find”. Otherwise, please output “Impossible”.

Sample Input

2

7
1 2
2 3
2 4
1 5
5 6
6 7
abcdefg
dbaefg

5
1 2
2 3
2 4
4 5
abcxy
yxbac

Sample Output

Case #1: Find
Case #2: Impossible

Source

2015 ACM/ICPC Asia Regional Shanghai Online

 

解题：点分治+hash

 debug大半天的成果啊

比如一个目标串是$abcdefg$,假设我们树分治的时候，选的根恰好是$d$,那么我们需要的怎样的hash信息？是不是从$d->a$以及$d->g$的hash信息啊，注意方向。d才是高位！！！

所以我们要预处理出来目标串每个字符么，向左走到端点已经向右走到端点的hash值。

在树分治的时候，我们可以从根到当前点，走出一条路，路上的点就会hash出一个值，根据深度，我们可以看看它跟这个长度的前缀配不配，或者跟这个长度的后缀配不配，配的话，我们要分别找剩下长度的后缀或者前缀是否存在。

比放说根就是$d$,当前走到深度4，那么我们就可以看看目标串从4位置hash到 1位置的hash跟当前路径的hash值等否？如果相等，那么需要一段什么样的值呢？

需要一个后缀，从d开始，走到g这段的hash值，是否在前面的搜索过程中出现过，如果出现过，那么好了a到d的有了，d到g的也有了，那么a到g的就有了，答案就找到了。

 #include <bits/stdc++.h>
 using namespace std;
 using ULL = unsigned long long;
 const int maxn = ;
 const ULL Base = ;
 struct arc{
     int to,next;
     arc(int x = ,int y = -){
         to = x;
         next = y;
     }
 }e[maxn<<];
 bool vis[maxn];
 int head[maxn],sz[maxn],maxson[maxn],pre[maxn],suf[maxn],tot,len,cnt;
 ULL Pre[maxn],Suf[maxn],B[maxn] = {};
 char sa[maxn],sb[maxn];
 void add(int u,int v){
     e[tot] = arc(v,head[u]);
     head[u] = tot++;
 }
 void dfs(int u,int fa){
     sz[u] = ;
     maxson[u] = ;
     for(int i = head[u]; ~i; i = e[i].next){
         if(e[i].to == fa || vis[e[i].to]) continue;
         dfs(e[i].to,u);
         sz[u] += sz[e[i].to];
         maxson[u] = max(maxson[u],sz[e[i].to]);
     }
 }
 int FindRoot(int sum,int u,int fa){
     int ret = u;
     maxson[u] = max(maxson[u],sum - sz[u]);
     for(int i = head[u]; ~i; i = e[i].next){
         if(e[i].to == fa || vis[e[i].to]) continue;
         int x = FindRoot(sum,e[i].to,u);
         if(maxson[x] < maxson[ret]) ret = x;
     }
     return ret;
 }
 bool cao(int u,ULL w,int fa,int depth,bool op) {
     if(depth > len) return false;
     w = w*Base + (ULL)sa[u];
     if(op) {
         if(w == Pre[depth] && suf[depth] == cnt) return true;
         if(w == Suf[len - depth + ] && pre[len - depth + ] == cnt) return true;
     } else {
         if(w == Pre[depth]) pre[depth] = cnt;
         if(w == Suf[len - depth + ]) suf[len - depth + ] = cnt;
     }
     for(int i = head[u]; ~i; i = e[i].next) {
         if(vis[e[i].to] || e[i].to == fa) continue;
         if(cao(e[i].to,w,u,depth + ,op)) return true;
     }
     return false;
 }
 bool solve(int u){
     dfs(u,);
     if(sz[u] < len) return false;
     int root = FindRoot(sz[u],u,);
     vis[root] = true;
     ++cnt;
     ULL w = sa[root];
     if(w == Pre[len]) return true;
     if(w == Pre[]) pre[] = cnt;
     if(w == Suf[len]) suf[len] = cnt;
     for(int i = head[root]; ~i; i = e[i].next){
         if(vis[e[i].to]) continue;
         if(cao(e[i].to,w,root,,true)) return true;
         cao(e[i].to,w,root,,false);
     }
     for(int i = head[root]; ~i; i = e[i].next){
         if(vis[e[i].to]) continue;
         if(solve(e[i].to)) return  true;
     }
     return false;
 }
 int main(){
     int kase,n,u,v,cs = ;
     for(int i = ; i < maxn; ++i) B[i] = B[i-]*Base;
     scanf("%d",&kase);
     while(kase--){
         scanf("%d",&n);
         memset(head,-,sizeof head);
         memset(vis,false,sizeof vis);
         memset(pre,,sizeof pre);
         memset(suf,,sizeof suf);
         tot = ;
         for(int i = ; i < n; ++i){
             scanf("%d%d",&u,&v);
             add(u,v);
             add(v,u);
         }
         scanf("%s%s",sa + ,sb + );
         len = strlen(sb + );
         for(int i = ; i <= len; ++i) Pre[i] = Pre[i-] + B[i-]*sb[i];
         Suf[len + ] = ;
         for(int i = len; i > ; --i) Suf[i] = Suf[i+] + B[len - i]*sb[i];
         printf("Case #%d: %s\n",cs++,solve()?"Find":"Impossible");
     }
     return ;
 }