Tree Traversals - Hard Version

Given the partial results of a binary tree's traversals in in-order, pre-order, and post-order. You are supposed to output the complete results and the level order traversal sequence of the corresponding tree.

Input Specification:

Each input file contains one test case. For each case, a positive integer N (≤) is given in the first line. Then three lines follow, containing the incomplete in-order, pre-order and post-order traversal sequences, respectively. It is assumed that the tree nodes are numbered from 1 to N and no number is given out of the range. A - represents a missing number.

Output Specification:

For each case, print in four lines the complete in-order, pre-order and post-order traversal sequences, together with the level order traversal sequence of the corresponding tree. The numbers must be separated by a space, and there must be no extra space at the beginning or the end of each line. If it is impossible to reconstruct the unique tree from the given information, simply print Impossible.

Sample Input 1:

9
3 - 2 1 7 9 - 4 6
9 - 5 3 2 1 - 6 4
3 1 - - 7 - 6 8 -

 

Sample Output 1:

3 5 2 1 7 9 8 4 6
9 7 5 3 2 1 8 6 4
3 1 2 5 7 4 6 8 9
9 7 8 5 6 3 2 4 1

 

Sample Input 2:

3
- - -
- 1 -
1 - -

 

Sample Output 2:

Impossible

#include<bits/stdc++.h>
using namespace std;
int n,t,flag;
vector<int> v0,vp;
vector<vector<int> > vd;
vector<vector<int> > v;
vector<vector<int> > vr;
vector<list<int> > vl(2);
vector<list<int> > vle(2);
bool ip2p(int i1,int i2,int p1,int p2,int pr,int d)
{
    int v11=v[1][p1];
    vp[pr]=v11;
    if(v[2][pr]&&(v[2][pr]!=v11))return false;
    int vds=vd.size();
    if(vds<=d)
    {
        vector<int> vdd(1,v11);
        vd.emplace_back(vdd);
    }
    else vd[d].emplace_back(v11);
    
    int i3=vr[0][v11-1];
    int lenl=i3-i1;
    int lenr=i2-i3;
    if(lenl)
    {
        if(lenr)return ip2p(i1,i3-1,p1+1,p1+lenl,pr-1-lenr,d+1)&&ip2p(i3+1,i2,p1+lenl+1,p2,pr-1,d+1);
        else return ip2p(i1,i3-1,p1+1,p1+lenl,pr-1-lenr,d+1);
    }
    else
    {
        if(lenr) return ip2p(i3+1,i2,p1+lenl+1,p2,pr-1,d+1);
        else return true;
    }
}
void dfs()
{
    if(flag==2)
    return;
    else if(!vle[0].empty())
    {
        int i=vl[0].front();
        int ie=vle[0].front();
        vle[0].pop_front();
        do
        {
            int ii=vl[0].front();
            vl[0].pop_front();
            v[0][ie]=ii;
            vr[0][ii-1]=ie;
            dfs();
            v[0][ie]=0;
            vr[0][ii-1]=-1;            
            vl[0].emplace_back(ii);
            
        }while(i!=vl[0].front());
        vle[0].emplace_front(ie);
    }
    else if(!vle[1].empty())
    {
        int i=vl[1].front();
        int ie=vle[1].front();
        vle[1].pop_front();
        do
        {
            int ii=vl[1].front();
            vl[1].pop_front();
            v[1][ie]=ii;
            vr[1][ii-1]=ie;
            dfs();
            v[1][ie]=0;
            vr[1][ii-1]=-1;    
            vl[1].emplace_back(ii);
        }while(i!=vl[1].front());
        vle[1].emplace_front(ie);
    }
    else
    {
        if(flag==2)
        return;
        else
        {
            if(ip2p(0,n-1,0,n-1,n-1,0))
            {
                flag++;
                if(flag==1)
                {
                    for(int i=0;i<2;i++)
                    for(int j=0;j<n;j++)
                    v0.emplace_back(v[i][j]);
                    for(auto i:vp)
                    v0.emplace_back(i);
                    for(auto i:vd)
                    for(auto j:i)
                    v0.emplace_back(j);
                }
            }
            vd.clear();
        }
    }
}
 
bool dfs(int in,int pre,int post,int s)
{
    if(!s)
    return true;
    else if(v[1][pre]||v[2][post+s-1])
    {
        int tm=max(v[1][pre],v[2][post+s-1]);
        if(v[1][pre]&&v[1][pre]!=tm) return false;
        if(v[2][post+s-1]&&v[2][post+s-1]!=tm) return false;
        int rt=vr[0][tm-1];
        int p1=v[1][pre];
        int p2=v[2][post+s-1];
        v[1][pre]=tm;
        v[2][post+s-1]=tm;
        if(rt<0)
        {
            for(int i=in;i<in+s;i++)
            {
                if(!v[0][i])
                {
                    int lenl=i-in;
                    int lenr=s-1-lenl;
                    if(lenl<0 || lenr<0)continue;
                    v[0][i]=tm;
                    vr[0][tm-1]=i;
                    if(dfs(in,pre+1,post,s-lenr-1)&&dfs(in+lenl+1,pre+1+lenl,post+lenl,s-lenl-1))
                    return true;
                    v[0][i]=0;
                    vr[0][tm-1]=-1;
                }
            }
            return false;
        }
        else
        {
            int lenl=rt-in;
            int lenr=s-1-lenl;
            if(lenl<0 || lenr<0)
            {
                v[1][pre]=p1;
                v[2][post+s-1]=p2;
                return false;
            }
            else if(dfs(in,pre+1,post,s-lenr-1)&&dfs(in+lenl+1,pre+1+lenl,post+lenl,s-lenl-1))
            return true;
            else
            {
                v[1][pre]=p1;
                v[2][post+s-1]=p2;
                return false;
            }
        }
    }
    else
    {
        for(int i=in;i<in+s;in++)
        {
            int lenl=i-in;
            int lenr=s-1-lenl;
            
            if(lenl<0 || lenr<0)
            {
                v[1][pre]=0;
                v[2][post+s-1]=0;
            }
            else if(!v[0][i])
            {
                v[0][i]=t;
                vr[0][t-1]=i;
                v[1][pre]=t;
                v[2][post+s-1]=t;
                if(dfs(in,pre+1,post,s-lenr-1)&&dfs(in+lenl+1,pre+1+lenl,post+lenl,s-lenl-1))
                return true;
                v[0][i]=0;
                vr[0][t-1]=-1;
            }
            else
            {
                v[1][pre]=v[0][i];
                v[2][post+s-1]=v[0][i];
                if(dfs(in,pre+1,post,s-lenr-1)&&dfs(in+lenl+1,pre+1+lenl,post+lenl,s-lenl-1))
                return true;
            }
            v[1][pre]=0;
            v[2][post+s-1]=0;
        }
        return false;
    }
}
void levelorder(int in,int pre,int s,int d)
{
    if(!s) return;
    else
    {
        int tm=v[1][pre];
        int rt=vr[0][tm-1];
        int lenl=rt-in;
        int lenr=s-1-lenl;
        if(d>=(int)vd.size())
        {
            vector<int> vt(1,tm);
            vd.emplace_back(vt);
        }
        else
        vd[d].emplace_back(tm);
        levelorder(in,pre+1,s-lenr-1,d+1);
        levelorder(in+lenl+1,pre+lenl+1,s-lenl-1,d+1);
    }
}
 
int main()
{
//    freopen("data.txt","r",stdin);
    scanf("%d",&n);
    v0.resize(n,0);
    vp.resize(n,0);
    v.resize(3,v0);
    v0.clear();
    v0.resize(n,-1);
    vr.resize(3,v0);
    v0.clear();
    flag=0;
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<n;j++)
        {
            scanf("%d",&v[i][j]);
            if(v[i][j])
            {
                t=v[i][j]-1;
                vr[i][t]=j;
            }
            else if(i<2)
                vle[i].emplace_back(j);
        }
        if(i<2)    for(int j=0;j<n;j++)
        {
            if(vr[i][j]<0)
            vl[i].emplace_back(j+1);
        }
    }
    if(n<100)
    {
        dfs();
        if(flag==1)
        {
            for(int i=0;i<4*n;i++)
            printf("%d%s",v0[i],(i+1)%n?" ":"\n");
        }
        else printf("Impossible");
    }
    else
    {
        dfs(0,0,0,n);
        for(int i=0;i<3*n;i++)
        printf("%d%s",v[i/n][i%n],(i+1)%n?" ":"\n");
        levelorder(0,0,n,0);
        printf("%d",vd[0][0]);
        for(int i=1;i<(int)vd.size();i++)
        for(int j=0;j<(int)vd[i].size();j++)
        printf(" %d",vd[i][j]);
    }
    return 0;
}