POI2011 Inspection

Inspection

POI2011

题意

1.一棵n个节点的树

2.先选择一个行动中心S

3.从S出发前往任意一个未检查的点(沿树上两点的唯一最短路走)，检查该节点，然后返回S。

4.检查完最后一个节点后不需要返回

5.相邻两次检查所经过的道路不允许有重复
即他每次从S出发走过的第一条边不能和上一次出发的相同

6.求以1~n为行动中心时，检查完所有点需要的最小时间，如果不可能则输出-1

解

1.基本思路
枚举每个点为根，然后树形dp

2.定义
重儿子:儿子中sz最大的点
最长链:从x(当前的根)向下，最长的链
次长链:从x(当前的根)向下，次长的链

3.分类讨论

①sz[重儿子]>n-sz[重儿子]
无解
因为除了根和重儿子以外，只有n-sz[重儿子]-1，
最多只能与n-sz[重儿子]个点组合


②sz[重儿子]=n-sz[重儿子] 
这时，最后一次访问必然是重儿子所在的子树
所以只能停在重儿子里
于是在重儿子里取一条最长链(这条最长链不能从当前的根里面连出来)
ans=遍历总边数*2-最长链

③其他情况
找到当前根结点下面的最长链即可
ans=遍历总边数*2-最长链

4.但是显然不能每个点的枚举一遍呀，但是又需要他们作为根时的结果，不如来一份换根dp
在dp换根的过程中：
设x->y(根由x换成了y，y是x的儿子)
①维护一个遍历总边数
这时x<->y这条边被多走了n-2*sz[y]
sum+=n-2*sz[y]

②维护一个最长链和次长链
可以y可以从x点拿一条不从y点连出来的链继承

每次dfs结束时，还原现场即可(在更新前先记录旧版本，回来直接赋值回去)

具体代码

#include<bits/stdc++.h>
using namespace std;
const int M=1000005;
int n;
long long ans[M];
int head[M],asdf;
struct edge {
    int to,nxt;
} G[M*2];
void add_edge(int a,int b) {
    G[++asdf].to=b;
    G[asdf].nxt=head[a];
    head[a]=asdf;
}
int dis[M][2],id[M][2];
int son[M],sz[M];
long long sum;
void dfs1(int x,int f) {
    sz[x]=1;
    son[x]=0;
    dis[x][0]=dis[x][1]=0;
    id[x][0]=id[x][1]=0;
    for(int i=head[x]; i; i=G[i].nxt) {
        int y=G[i].to;
        if(y==f)continue;
        dfs1(y,x);
        sum+=sz[y];
        if(dis[y][0]+1>dis[x][1]) {
            dis[x][1]=dis[y][0]+1;
            id[x][1]=y;
            if(dis[x][1]>dis[x][0]) {
                swap(dis[x][1],dis[x][0]);
                swap(id[x][1],id[x][0]);
            }
        }
        sz[x]+=sz[y];
        if(sz[y]>sz[son[x]])son[x]=y;
    }
}
void dfs2(int x,int f) {
    int msz=sz[son[x]],so=son[x];
    if(n-sz[x]>msz) {
        msz=n-sz[x];
        so=f;
    }
    if(msz>n-msz)ans[x]=-1;
    else if(msz==n-msz) {
        if(so!=f)ans[x]=2*sum-dis[so][0]-1;
        else {
            if(id[so][0]==x)ans[x]=2*sum-dis[so][1]-1;
            else ans[x]=2*sum-dis[so][0]-1;
        }
    } else {
        ans[x]=2*sum-dis[x][0];
    }
    for(int i=head[x]; i; i=G[i].nxt) {
        int y=G[i].to;
        if(y==f)continue;
        int id0=id[y][0],id1=id[y][1];
        int dis0=dis[y][0],dis1=dis[y][1];
        if(id[x][0]==y) {
            if(dis[x][1]+1>dis[y][1]) {
                dis[y][1]=dis[x][1]+1;
                id[y][1]=x;
                if(dis[y][1]>dis[y][0]) {
                    swap(dis[y][1],dis[y][0]);
                    swap(id[y][1],id[y][0]);
                }
            }
        } else {
            if(dis[x][0]+1>dis[y][1]) {
                dis[y][1]=dis[x][0]+1;
                id[y][1]=x;
                if(dis[y][1]>dis[y][0]) {
                    swap(dis[y][1],dis[y][0]);
                    swap(id[y][1],id[y][0]);
                }
            }
        }
        sum+=n-2*sz[y];
        dfs2(y,x);
        sum-=n-2*sz[y];
        id[y][0]=id0,id[y][1]=id1;
        dis[y][0]=dis0,dis[y][1]=dis1;
    }
}
int main() {
    int a,b;
    scanf("%d",&n);
    for(int i=1; i<n; i++) {
        scanf("%d %d",&a,&b);
        add_edge(a,b);
        add_edge(b,a);
    }
    dfs1(1,0);
    dfs2(1,0);
    for(int i=1; i<=n; i++)printf("%lld\n",ans[i]);
    return 0;
}