【2016北京集训测试赛（八）】 直径 （虚树+树的直径）

Description

　　注意：时限更改为4s

---

题解

　　考虑最原始的直径求法：找到离根节点（或离其他任意一点）最远的节点far1，再从far1出发找到离far1最远的节点far2，far1至far2的距离即为直径。

　　做完下面的优化就可以直接跑这个经典求法啦。

---

复制的问题

　　题目中提到了将原树的子树复制成新子树这一操作，显然如果我们将子树真正复制出来是会爆炸的。

　　实际上我们可以将每棵新子树中，真正有用的节点提取出来，以简化每个子树的结构，再按照题目的要求连接各个新子树。

　　我们用虚树来重构每一棵子树。每棵子树的虚树的关键点应至少包含：

• 子树的根节点。
• 这棵子树内部的直径的两端节点。
• 题目所要求的，该子树要向其他子树连接的边的起点。

　　子树内部的直径求法可以O(n)得到。对于一棵根节点为u的子树，它的直径要么在u的某个儿子v下面，要么由该树内来自不同子树的两个深度最大的节点组成。维护最大值和次大值，更新即可。

---

 编号问题　　

　　虚树重构时的重编号需要注意处理。。。这估计是这题最恶心的了。。。还有连子树边的操作也是。

　　我们应该先对每棵子树进行重编号，再进行连子树边的操作。可以用map存储原节点对应的新编号，（实际上，对于某一个点，它在不同新子树中的新编号是不相同的）。

　　在建立虚树的时候，不论是压栈还是弹栈都是对原来的节点进行操作，只不过连边的时候要连接它们的新编号。

---

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=300010,Bas=20;
int n,m,tot,bas,ho[N],side[N][3],pre[N][Bas+1],dep[N];
ll far[2];
int timecnt,dfn[N],rt[N],cnt,newid[N],H[N*10];
vector<int> use[N];
map<int,int> tree[N];
struct Edge{int v,w,next;}g[N*2+N*20];
struct WaitEdge{
    int a,b,c,d;
    WaitEdge(){}
    WaitEdge(int aa,int bb,int cc,int dd){a=aa;b=bb;c=cc;d=dd;}
    void get(int &aa,int &bb,int &cc,int &dd){aa=a;bb=b;cc=c;dd=d;}
}waitedge[N];
struct MT{
    int a,as,b,bs;
    MT(){a=as=b=bs=-1;}
    void push(int c,int cs){
        if(c>a)
            b=a, bs=as,
            a=c, as=cs;
        else if(c>b)
            b=c, bs=cs;
    }
}mt[N];
inline void addEdge(int u,int v,int w,int *h){
    if(u==v) return;
    g[++tot].v=v; g[tot].w=w; g[tot].next=h[u]; h[u]=tot;
}
void preDfs(int u,int fa,int deep){
    dfn[u]=++timecnt;
    dep[u]=deep;
    pre[u][0]=fa;
    for(int i=1;i<=bas;i++) pre[u][i]=pre[pre[u][i-1]][i-1];
    for(int i=ho[u],v;i;i=g[i].next){
        if((v=g[i].v)!=fa){
            preDfs(v,u,deep+1);
            mt[u].push(mt[v].a+1,mt[v].as);
            if(side[v][0]&&side[v][0]>side[u][0])
                side[u][0]=side[v][0],side[u][1]=side[v][1],side[u][2]=side[v][2];
        }
    }
    mt[u].push(0,u);
    if(mt[u].as!=-1&&mt[u].bs==-1){
        side[u][0]=1;
        side[u][1]=side[u][2]=u;
    }
    else
    if(mt[u].as&&mt[u].bs&&mt[u].a+mt[u].b+1>side[u][0]){
        side[u][0]=mt[u].a+mt[u].b+1;
        side[u][1]=mt[u].as;
        side[u][2]=mt[u].bs;
    }
}
int getLca(int a,int b){
    if(dep[a]<dep[b]) swap(a,b);
    for(int i=bas;i>=0;i--)
        if(dep[pre[a][i]]>=dep[b]) 
            a=pre[a][i];
    if(a==b) return a;
    for(int i=bas;i>=0;i--)
        if(pre[a][i]!=pre[b][i]) 
            a=pre[a][i], b=pre[b][i];
    return pre[a][0];
}
bool cmp(int x,int y){return dfn[x]<dfn[y];}
int lis[N*10],K,st[N*10],top,tms[N*10];
void build(int id){
    int u=rt[id],vsiz=use[id].size();
    K=3;
    lis[1]=u; lis[2]=side[u][1]; lis[3]=side[u][2];
    for(int i=0;i<vsiz;i++) lis[++K]=use[id][i];
    sort(lis+1,lis+1+K);
    K=unique(lis+1,lis+1+K)-lis-1;
    sort(lis+1,lis+1+K,cmp);
    for(int i=1;i<=K;i++) newid[lis[i]]=++cnt,tms[lis[i]]=id;
    if(K>1){
        st[1]=lis[1]; st[2]=lis[2];
        top=2;
        for(int i=3;i<=K;i++){
            int now=lis[i],lca=getLca(now,st[top]);
            while(1){
                if(dep[lca]>=dep[st[top-1]]){
                    if(tms[lca]!=id) newid[lca]=++cnt,tms[lca]=id;
                    addEdge(newid[lca],newid[st[top]],dep[st[top]]-dep[lca],H);
                    addEdge(newid[st[top]],newid[lca],dep[st[top]]-dep[lca],H);
                    top--;
                    if(st[top]!=lca) st[++top]=lca;
                    break;
                }
                addEdge(newid[st[top-1]],newid[st[top]],dep[st[top]]-dep[st[top-1]],H);
                addEdge(newid[st[top]],newid[st[top-1]],dep[st[top]]-dep[st[top-1]],H);
                top--;
            }
            if(st[top]!=now)
                st[++top]=now;
        }
        for(;top>1;top--){
            addEdge(newid[st[top]],newid[st[top-1]],dep[st[top]]-dep[st[top-1]],H);
            addEdge(newid[st[top-1]],newid[st[top]],dep[st[top]]-dep[st[top-1]],H);
        }
    }
    for(int i=1;i<=K;i++)
        tree[id][lis[i]]=newid[lis[i]];
}
void dfs(int u,int fa,ll dis){
    if(dis>far[0])
        far[0]=dis,
        far[1]=u;
    for(int i=H[u],v;i;i=g[i].next)
        if((v=g[i].v)!=fa)
            dfs(v,u,dis+g[i].w);
}
int main(){
    scanf("%d%d",&n,&m);
    bas=((int)log2(n))+1;
    for(int i=1,x,y;i<n;i++)
        scanf("%d%d",&x,&y),
        addEdge(x,y,1,ho),addEdge(y,x,1,ho);
    preDfs(1,0,1);
    for(int i=1,x;i<=m;i++)
        scanf("%d",&rt[i]);        
    for(int i=1,a,b,c,d;i<m;i++){    
        scanf("%d%d%d%d",&a,&b,&c,&d);
        waitedge[i]=WaitEdge(a,b,c,d);
        use[a].push_back(b); 
        use[c].push_back(d);
    }    
    for(int i=1;i<=m;i++)
        build(i);
    for(int i=1;i<m;i++){
        int a,b,c,d,x,y;
        waitedge[i].get(a,b,c,d);
        x=tree[a][b]; y=tree[c][d];
        addEdge(x,y,1,H); addEdge(y,x,1,H);
    }
    dfs(tree[1][rt[1]],0,1);
    int t=far[1];
    far[0]=far[1]=0;
    dfs(t,0,1);
    printf("%lld
",far[0]);
    return 0;
}