bzoj 3611: [Heoi2014]大工程 虚树

Description

国家有一个大工程，要给一个非常大的交通网络里建一些新的通道。
我们这个国家位置非常特殊，可以看成是一个单位边权的树，城市位于顶点上。
在 2 个国家 a,b 之间建一条新通道需要的代价为树上 a,b 的最短路径。
现在国家有很多个计划，每个计划都是这样，我们选中了 k 个点，然后在它们两两之间 新建 C(k,2)条 新通道。
现在对于每个计划，我们想知道：
1.这些新通道的代价和
2.这些新通道中代价最小的是多少
3.这些新通道中代价最大的是多少
Input

第一行 n 表示点数。

接下来 n-1 行，每行两个数 a,b 表示 a 和 b 之间有一条边。
点从 1 开始标号。 接下来一行 q 表示计划数。
对每个计划有 2 行，第一行 k 表示这个计划选中了几个点。
第二行用空格隔开的 k 个互不相同的数表示选了哪 k 个点。
Output

输出 q 行，每行三个数分别表示代价和，最小代价，最大代价。

Sample Input
10
2 1
3 2
4 1
5 2
6 4
7 5
8 6
9 7
10 9
5
2
5 4
2
10 4
2
5 2
2
6 1
2
6 1

Sample Output
3 3 3
6 6 6
1 1 1
2 2 2
2 2 2

HINT
n<=1000000
q<=50000并且保证所有k之和<=2*n

分析：
直接把虚树建出来，然后枚举$lca$，处理出一定经过这个点的路径的最大值，最小值，权值和，再合并整棵树的答案。
洛谷上莫名RE，好像好多人都RE了，连标程都RE了。

代码：

/**************************************************************
    Problem: 3611
    User: liangzihao
    Language: C++
    Result: Accepted
    Time:8964 ms
    Memory:169192 kb
****************************************************************/

#include <iostream>
#include <cmath>
#include <cstdio>
#include <algorithm>
#define LL long long

const int maxn=1e6+7;
const int inf=0x3f3f3f3f;

using namespace std;

int n,m,x,y,cnt,tot,top;
int ls[maxn],dfn[maxn],dep[maxn],a[maxn],q[maxn];
int maxx[maxn],minn[maxn],size[maxn],pre[maxn];
LL ans1;
LL sum[maxn];
int ans2,ans3;
int f[maxn][20];

struct node{
    int x,key;
}b[maxn];

struct edge{
    int y,next;
}g[maxn*2];

bool cmp(int x,int y)
{
    return dfn[x]<dfn[y];
}

bool cmp1(node x,node y)
{
    return dfn[x.x]<dfn[y.x];
}

void add(int x,int y)
{
    g[++cnt]=(edge){y,ls[x]};
    ls[x]=cnt;
}

void dfs(int x,int fa)
{
    dfn[x]=++cnt;
    dep[x]=dep[fa]+1;
    f[x][0]=fa;
    for (int i=ls[x];i>0;i=g[i].next)
    {
        int y=g[i].y;
        if (y==fa) continue;
        dfs(y,x);
    }
}

int lca(int x,int y)
{
    if (dep[x]>dep[y]) swap(x,y);
    int d=dep[y]-dep[x],k=19,t=1<<k;
    while (d)
    {
        if (d>=t)
        {
            d-=t;
            y=f[y][k];
        }
        t/=2,k--;
    }
    if (x==y) return x;
    k=19;
    while (k>=0)
    {
        if (f[x][k]!=f[y][k])
        {
            x=f[x][k];
            y=f[y][k];
        }
        k--;
    }
    return f[x][0];
}

int main()
{
    scanf("%d",&n);
    for (int i=1;i<n;i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y);
        add(y,x);
    }
    cnt=0;
    dfs(1,0);
    for (int j=1;j<20;j++)
    {
        for (int i=1;i<=n;i++)
        {
            f[i][j]=f[f[i][j-1]][j-1];
        }
    }
    scanf("%d",&m);
    for (int i=1;i<=m;i++)
    {
        scanf("%d",&tot);
        for (int j=1;j<=tot;j++) scanf("%d",&a[j]);      
        sort(a+1,a+tot+1,cmp);
        top=0,cnt=0;
        q[++top]=a[1];
        b[++cnt]=(node){a[1],1};
        for (int j=2;j<=tot;j++)
        {
            b[++cnt]=(node){a[j],1};
            int d=lca(q[top],a[j]);
            if (d==q[top]) q[++top]=a[j];
            else
            {
                while (dep[q[top-1]]>=dep[d])
                {
                    pre[q[top]]=q[top-1];
                    top--;
                }
                if (q[top]!=d)
                {
                    pre[q[top]]=d;
                    q[top]=d;
                    b[++cnt]=(node){d,0};
                }
                q[++top]=a[j];
            }
        }
        while (top>1) pre[q[top]]=q[top-1],top--;
        sort(b+1,b+cnt+1,cmp1);
        for (int i=1;i<=cnt;i++)
        {
            if (b[i].key)
            {
                size[b[i].x]=1;
                maxx[b[i].x]=minn[b[i].x]=sum[b[i].x]=0;
            }
            else
            {
                size[b[i].x]=maxx[b[i].x]=sum[b[i].x]=0;
                minn[b[i].x]=inf;
            }
        }
        ans1=ans3=0;
        ans2=inf;       
        for (int i=cnt;i>1;i--)
        {
            int x=b[i].x;
            ans1+=sum[pre[x]]*(LL)size[x]+sum[x]*(LL)size[pre[x]]+(LL)size[x]*(LL)size[pre[x]]*((LL)dep[x]-(LL)dep[pre[x]]);
            ans2=min(ans2,minn[pre[x]]+minn[x]+dep[x]-dep[pre[x]]);
            ans3=max(ans3,maxx[pre[x]]+maxx[x]+dep[x]-dep[pre[x]]);
            size[pre[x]]+=size[x];
            sum[pre[x]]+=sum[x]+(LL)size[x]*((LL)dep[x]-(LL)dep[pre[x]]);
            minn[pre[x]]=min(minn[pre[x]],minn[x]+dep[x]-dep[pre[x]]);
            maxx[pre[x]]=max(maxx[pre[x]],maxx[x]+dep[x]-dep[pre[x]]);
        }
        printf("%lld %d %d\n",ans1,ans2,ans3);
    }

}