Hdu 5469 Antonidas(只需要判断可不可行的树分治)

传送门:Hdu 5469 Antonidas

---

题意:给你一棵树,有n个结点,每个结点有一个字母,找出一条链,它的字母组成为s,问有没有这样的链(n<=1e5)

---

思路:
对于一条链(u->v),可以分成u>lca(u,v),lca(u,v)->v,又因为对于树只能处理出lca(u,v)->u或者v的Hash值,所以我们刚开始对于s字符串的Hash要分成正向和反向
刚开始的时候用了map去计算组成的方案数(因为树分治的时候要进行去重),然后T了
而我们可以发现,其实并不需要计算有多少种方式构造出答案,只需要判断有无方案,所以我们可以去掉map形成的logn的时间复杂度
方法就是处理到根的时候分成不同的子树直接处理

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MP(x,y) make_pair(x,y)
typedef pair<int,int> PI;
const int MOD=1000173169;
const int P1=31,P2=13;
const int N=1e4+5;
int n;
int size[N],f[N],root,Count;
bool Del[N];
char a[N],s[N];

struct Edge{
    int to,next;
}e[N*2];
int tot,head[N];

void init(){
    tot=0;
    memset(head,-1,sizeof(head));
}

void addedge(int u,int v){
    e[tot].to=v;
    e[tot].next=head[u];
    head[u]=tot++;
}

void getroot(int u,int pre){
    f[u]=0,size[u]=1;
    for(int i=head[u];i!=-1;i=e[i].next){
        int v=e[i].to;
        if(!Del[v]&&v!=pre){
            getroot(v,u);
            size[u]+=size[v];
            f[u]=max(size[v],f[u]);
        }
    }
    f[u]=max(f[u],Count-size[u]);
    if(f[u]<f[root])    root=u;
}

vector<int>tmp;
int Belong_pre[N],Belong_suf[N];
bool flag;
int len,F1[N],rev_F1[N],Pow1[N],F2[N],rev_F2[N],Pow2[N];

void getdeep(int u,int pre,int mul1,int mul2,int dep,int Belong){
    mul1=(ll)(1LL*mul1*P1+a[u])%MOD;
    mul2=(ll)(1LL*mul2*P2+a[u])%MOD;
    if(mul1==F1[dep]&&mul2==F2[dep]){
        if(Belong_pre[dep]==0)
            Belong_pre[dep]=Belong;
        if((Belong_suf[len+1-dep]!=0&&Belong_suf[len+1-dep]!=Belong)||dep==len){
            flag=true;
            return ;
        }
        tmp.push_back(dep);
    }
    if(mul1==rev_F1[dep]&&mul2==rev_F2[dep]){
        if(Belong_suf[dep]==0)
            Belong_suf[dep]=Belong;
        if((Belong_pre[len+1-dep]!=0&&Belong_pre[len+1-dep]!=Belong)||dep==len){
            flag=true;
            return ;
        }
        tmp.push_back(dep);
    }
    size[u]=1;
    for(int i=head[u];i!=-1;i=e[i].next){
        int v=e[i].to;
        if(Del[v]||v==pre)
            continue;
        getdeep(v,u,mul1,mul2,dep+1,Belong);
        size[u]+=size[v];
    }
}

void work(int u){
    if(len==1&&a[u]==s[1]){
        flag=true;
        return ;
    }
    Del[u]=true;
    for(int i=head[u];i!=-1;i=e[i].next){
        int v=e[i].to;
        if(!Del[v])
            getdeep(v,0,a[u],a[u],2,v);
        if(flag)
            return ;
    }
    for(int i=0;i<tmp.size();i++)
        Belong_suf[tmp[i]]=Belong_pre[tmp[i]]=0;
    for(int i=head[u];i!=-1;i=e[i].next){
        int v=e[i].to;
        if(!Del[v]){
            if(size[v]<len)
                continue;
            Count=f[0]=size[v];
            getroot(v,root=0);
            work(root);
        }
    }
}

int main(){
    int _,u,v,case1=1;
    scanf("%d",&_);
    while(_--){
        scanf("%d",&n);
        init();
        memset(Belong_suf,0,sizeof(Belong_suf));
        memset(Belong_pre,0,sizeof(Belong_pre));
        for(int i=1;i<n;i++){
            scanf("%d%d",&u,&v);
            addedge(u,v),addedge(v,u);
        }
        scanf("%s%s",a+1,s+1);
        len=strlen(s+1);
        Pow1[0]=1,Pow2[0]=1;
        for(int i=1;i<=len;i++) Pow1[i]=1LL*Pow1[i-1]*P1%MOD,Pow2[i]=1LL*Pow2[i-1]*P2%MOD;
        for(int i=1;i<=len;i++){
            F1[i]=(1LL*Pow1[i-1]*s[i]+F1[i-1])%MOD;  //长度为i的前缀
            F2[i]=(1LL*Pow2[i-1]*s[i]+F2[i-1])%MOD;
        }
        reverse(s+1,s+len+1);
        for(int i=1;i<=len;i++){
            rev_F1[i]=1LL*(1LL*Pow1[i-1]*s[i]+rev_F1[i-1])%MOD;    //长度为i的后缀
            rev_F2[i]=1LL*(1LL*Pow2[i-1]*s[i]+rev_F2[i-1])%MOD;
        }
        memset(Del,false,sizeof(Del)),Count=f[0]=n;
        getroot(1,root=0);
        flag=false;
        work(root);
        if(flag)
            printf("Case #%d: Find\n",case1++);
        else
            printf("Case #%d: Impossible\n",case1++);
    }
    return 0;
}