[zoj3990]Tree Equation

记$dep(T)$为树$T$的深度（根节点深度为0），则有$egin{cases}dep(A+B)=max(dep(A),dep(B))\dep(Acdot B)=dep(A)+dep(B)end{cases}$

考虑$C$中最深的点，对其来源于$AX$还是$BY$分类讨论（不妨假设是前者），再取出其深度为$dep(A)$的祖先，那么$X$即只能取该祖先的子树

确定$X$后，求出$AX$并在$C$中去掉，再类似地求出$Y$并判定即可

过程中需要实现一个树同构的判定，简单哈希即可

时间复杂度为$o(nlog n)$，可以通过

（实现可能略微有一些繁琐，由于无法提交并不保证代码正确，仅供参考）

#include<bits/stdc++.h>
using namespace std;
#define N 100005
#define mod 998244353
#define ll long long
int t,num[11],seed[N];
map<int,vector<int> >mat;
map<int,vector<int> >::iterator it;
int read(){
    int x=0;
    char c=getchar();
    while ((c<'0')||(c>'9'))c=getchar();
    while ((c>='0')&&(c<='9')){
        x=x*10+c-'0';
        c=getchar();
    }
    return x;
}
void write(int x,char c=''){
    while (x){
        num[++num[0]]=x%10;
        x/=10;
    }
    if (!num[0])putchar('0');
    while (num[0])putchar(num[num[0]--]+'0');
    putchar(c);
}
struct Tree{
    int n,rt,mx,fa[N],dep[N],sz[N],f[N];
    vector<int>v[N];
    bool operator == (const Tree &T)const{
        return (sz[rt]==T.sz[T.rt])&&(f[rt]==T.f[T.rt]);
    }
    void Read(){
        for(int i=1;i<=n;i++)v[i].clear();
        for(int i=1;i<=n;i++){
            int x=read();
            if (!x)rt=i;
            else v[x].push_back(i);
        }
    }
    void Write(){
        for(int i=1;i<n;i++)write(fa[i],' ');
        write(fa[n],'
');
    }
    void dfs(int k,int s){
        dep[k]=s,sz[k]=f[k]=1;
        for(int i=0;i<v[k].size();i++){
            fa[v[k][i]]=k,dfs(v[k][i],s+1);
            sz[k]+=sz[v[k][i]];
            f[k]=(f[k]+(ll)f[v[k][i]]*seed[sz[v[k][i]]])%mod;
        }
    }
    void build(){
        fa[rt]=0,dfs(rt,0);
        mx=0;
        for(int i=1;i<=n;i++)mx=max(mx,dep[i]);
    }
    void get(Tree &T,int k,int f){
        int id=++T.n;
        T.v[id].clear();
        if (f)T.v[f].push_back(id); 
        for(int i=0;i<v[k].size();i++)get(T,v[k][i],id);
    }
}A,B,C,X,Y,T,T0;
void mul(Tree &A,Tree &B,Tree &T){
    T.n=A.n*B.n,T.rt=(A.rt-1)*B.n+1;
    for(int i=1;i<=T.n;i++)T.v[i].clear();
    for(int i=1;i<=A.n;i++){
        for(int j=0;j<A.v[i].size();j++)T.v[(i-1)*B.n+1].push_back((A.v[i][j]-1)*B.n+1);
        for(int j=1;j<=B.n;j++)
            for(int k=0;k<B.v[j].size();k++)T.v[(i-1)*B.n+j].push_back((i-1)*B.n+B.v[j][k]);
    }
}
bool dec(Tree &A,Tree &B,Tree &T){
    mat.clear();
    for(int i=0;i<A.v[A.rt].size();i++)mat[A.f[A.v[A.rt][i]]].push_back(A.v[A.rt][i]);
    T.n=T.rt=1,T.v[1].clear();
    for(int i=0;i<B.v[B.rt].size();i++){
        int x=B.f[B.v[B.rt][i]];
        if (mat[x].empty())return 0;
        mat[x].pop_back();
    }
    for(it=mat.begin();it!=mat.end();it++){
        vector<int>v=(*it).second;
        for(int i=0;i<v.size();i++)A.get(T,v[i],1);
    }
    return 1;
}
bool calc(){
    int pos;
    for(int i=0;i<=C.n;i++)
        if (C.dep[i]==C.mx)pos=i;
    while (C.dep[pos]!=A.mx)pos=C.fa[pos];
    X.n=0,X.rt=1,C.get(X,pos,0),X.build();
    if ((ll)A.n*X.n>C.n)return 0;
    mul(A,X,T),T.build();
    if (!dec(C,T,T0))return 0;
    T0.build();
    for(int i=0;i<=T0.n;i++)
        if (T0.dep[i]==T0.mx)pos=i;
    while (T0.dep[pos]!=B.mx)pos=T0.fa[pos];
    Y.n=0,Y.rt=1,T0.get(Y,pos,0),Y.build();
    if ((ll)B.n*Y.n!=T0.n)return 0;
    mul(B,Y,T),T.build();
    return T==T0;
}
int main(){
    srand(time(0));
    for(int i=0;i<N;i++)
        for(int j=0;j<60;j++)seed[i]=((seed[i]<<1)+rand()%2)%mod;
    t=read();
    while (t--){
        A.n=read(),B.n=read(),C.n=read();
        A.Read(),B.Read(),C.Read();
        A.build(),B.build(),C.build();
        if (calc()){
            write(X.n,' '),write(Y.n,'
');
            X.Write(),Y.Write();
            continue;
        }
        swap(A,B);
        if (!calc())printf("Impossible
");
        else{
            write(Y.n,' '),write(X.n,'
');
            Y.Write(),X.Write();
        }
    }
    return 0;
}