主席树+LCA--HDU6723（wls 的树）

题意：http://acm.hdu.edu.cn/showproblem.php?pid=6723

如题。

思路：

http://acm.hdu.edu.cn/showproblem.php?pid=6723 差不多了。

#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
#include <cstdio>//sprintf islower isupper
#include <cstdlib>//malloc  exit strcat itoa system("cls")
#include <iostream>//pair
#include <fstream>//freopen("C:\Users\13606\Desktop\Input.txt","r",stdin);
#include <bitset>
//#include <map>
//#include<unordered_map>
#include <vector>
#include <stack>
#include <set>
#include <string.h>//strstr substr strcat
#include <string>
#include <time.h>// srand(((unsigned)time(NULL))); Seed n=rand()%10 - 0~9;
#include <cmath>
#include <deque>
#include <queue>//priority_queue<int, vector<int>, greater<int> > q;//less
#include <vector>//emplace_back
//#include <math.h>
#include <cassert>
#include <iomanip>
//#include <windows.h>//reverse(a,a+len);// ~ ! ~ ! floor
#include <algorithm>//sort + unique : sz=unique(b+1,b+n+1)-(b+1);+nth_element(first, nth, last, compare)
using namespace std;//next_permutation(a+1,a+1+n);//prev_permutation
//******************
clock_t __START,__END;
double __TOTALTIME;
void _MS(){__START=clock();}
void _ME(){__END=clock();__TOTALTIME=(double)(__END-__START)/CLOCKS_PER_SEC;cout<<"Time: "<<__TOTALTIME<<" s"<<endl;}
//***********************
#define rint register int
#define fo(a,b,c) for( a=b;a<=c;++a)
#define fr(a,b,c) for( a=b;a>=c;--a)
#define mem(a,b) memset(a,b,sizeof(a))
#define pr printf
#define sc scanf
#define ls rt<<1
#define rs rt<<1|1
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef unsigned long long ull;
typedef long long ll;
typedef double db;
const db E=2.718281828;
const db PI=acos(-1.0);
const ll INF=(1LL<<60);
const int inf=(1<<30);
const db ESP=1e-9;
const int mod=(int)1e9+7;
const int N=(int)2e5+10;

int tot;
int root[N];//forest_root;
struct node
{
    int l,r,sz;
}tr[N*55];//Log(n)

struct asd
{
    int x,fa,len;
}a[N];
//=========================================主席树
int Build(int l,int r)
{
    int now=++tot;
    tr[now].sz=0;
    int mid=(l+r)>>1;
    if(l<r)
    {
        tr[now].l=Build(l,mid);
        tr[now].r=Build(mid+1,r);
    }
    return now;
}
int update(int pre,int l,int r,int x)
{
    int now=++tot;
    tr[now].sz=tr[pre].sz+1;
    tr[now].l=tr[pre].l;
    tr[now].r=tr[pre].r;
    if(l<r)
    {
        int mid=(l+r)>>1;
        if(x>mid)
            tr[now].r=update(tr[pre].r,mid+1,r,x);
        else
            tr[now].l=update(tr[pre].l,l,mid,x);
    }
    return now;
}
int Query_big_cnt(int u,int v,int l,int r,int x)
{
    if(x==0)return 0;
    if(l==r)return 0;//!!!!!!!!!!

    int mid=(l+r)>>1;
    int temp=tr[tr[v].r].sz-tr[tr[u].r].sz;
    int ans=0;
    if(x<=mid)
        ans=Query_big_cnt(tr[u].l,tr[v].l,l,mid,x)+temp;
    else
        ans=Query_big_cnt(tr[u].r,tr[v].r,mid+1,r,x);
    return ans;
}
int Query_max(int u,int v,int l,int r)
{
    if(l==r)return l;//!!!!!!!!!!

    int mid=(l+r)>>1;
    int temp=tr[tr[v].r].sz-tr[tr[u].r].sz;
    int ans=0;
    if(!temp)
        ans=Query_max(tr[u].l,tr[v].l,l,mid);
    else
        ans=Query_max(tr[u].r,tr[v].r,mid+1,r);
    return ans;
}
//------------------------------------------------MAP
class MAP
{
public:
    struct EDGE
    {
        int to,next;
        int dis;
    }edge[N];

    int tot;
    int head[N];

    int dfn[N],DFN,SZ[N];
    void Init(int n)
    {
        tot=DFN=0;
        for(int i=0;i<=n;++i)
            head[i]=SZ[i]=dfn[i]=0;
    }
    void add(int from,int to,int dis)
    {
        ++tot;
        edge[tot].to=to;
        edge[tot].dis=dis;
        edge[tot].next=head[from];
        head[from]=tot;
    }
    int dfs(int u,int fa)
    {
        dfn[u]=++DFN;
        a[DFN]={u,DFN,1};
        SZ[dfn[u]]=1;
        for(int i=head[u];i;i=edge[i].next)
        {
            int to=edge[i].to;
            if(to!=fa)
                SZ[dfn[u]]+=dfs(to,u);
        }
        return SZ[dfn[u]];
    }
}mp;
//-----------------------------------------------LCA
int fa[N],dis[N],deep[N],P[N][20];

void dfs(int now,int pre,int depth)
{
    int i;
    deep[now]=depth;
    fa[now]=pre;
    for(i=mp.head[now];i;i=mp.edge[i].next)
    {
        int to=mp.edge[i].to;
        if(to!=pre)
        {
            dis[to]=dis[now]+mp.edge[i].dis;
            dfs(to,now,depth+1);
        }
    }
}

void init(int n)
{
    int i,j;
    for(j=0;(1<<j)<=n;j++)
        fo(i,1,n)
            P[i][j]=-1;

    fo(i,1,n)P[i][0]=fa[i];

    for(j=1;(1<<j)<=n;j++)
        fo(i,1,n)
            if(P[i][j-1]!=-1)
                P[i][j]=P[P[i][j-1]][j-1];
}

int LCA(int a,int b)
{
    int i,j;
    if(deep[a]<deep[b])swap(a,b);
    for(i=0;(1<<i)<=deep[a];i++);
    i--;

    fr(j,i,0)
        if(deep[a]-(1<<j)>=deep[b])
            a=P[a][j];
    if(a==b)return a;
    fr(j,i,0)
    {
        if(P[a][j]!=-1&&P[a][j]!=P[b][j])
        {
            a=P[a][j];
            b=P[b][j];
        }
    }
    return fa[a];
}
//-------------------------------------------------
int find(int x)
{
    while(a[x].fa!=x)
        x=a[x].fa;
    return x;
}

void solve()
{
    int n;
    sc("%d",&n);
    tot=0;
    mp.Init(n);
    for(int i=1;i<n;++i)
    {
        int u,v;
        sc("%d%d",&u,&v);
        mp.add(u,v,1);
        mp.add(v,u,1);
    }
    mp.dfs(1,-1);
    root[0]=Build(1,n);
    for(int i=1;i<=n;++i)
        root[i]=update(root[i-1],1,n,a[i].x);

    dis[1]=0;
    dfs(1,-1,0);
    init(n);

    int m;
    sc("%d",&m);
    for(int i=1;i<=m;++i)
    {
        int op;
        sc("%d",&op);
        if(op==1)
        {
            int x;
            sc("%d",&x);
            int pos=mp.dfn[x];
            if(a[pos].fa!=pos)continue;
            for(int now=pos+a[pos].len;now<=mp.SZ[pos]+pos-1;now+=a[pos].len)
            {
                a[now].fa=pos;
            }
            a[pos].len=mp.SZ[pos];
        }
        else
        {
            int u,v;
            sc("%d%d",&u,&v);
            int posu=mp.dfn[u];
            int posv=mp.dfn[v];
            int fau=find(posu);
            int fav=find(posv);
            int cntu=Query_big_cnt(root[fau-1],root[a[fau].len+fau-1],1,n,u);
            int cntv=Query_big_cnt(root[fav-1],root[a[fav].len+fav-1],1,n,v);
            if(fau==fav)
            {
                pr("%d
",abs(cntu-cntv));
                continue;
            }
            int len=dis[a[fav].x]+dis[a[fau].x]-2*dis[LCA(a[fau].x,a[fav].x)];
            len+=cntu+cntv;
            pr("%d
",len);
        }
    }
}

int main()
{
    int T;
    sc("%d",&T);
    while(T--)solve();
    return 0;
}

/**************************************************************************************/