CF 219D Choosing Capital for Treeland 树形DP 好题

一个国家，有n座城市，编号为1~n，有n-1条有向边

如果不考虑边的有向性，这n个城市刚好构成一棵树

现在国王要在这n个城市中选择一个作为首都

要求:从首都可以到达这个国家的任何一个城市(边是有向的)

所以一个城市作为首都，可能会有若干边需要改变方向

现在问，选择哪些城市作为首都，需要改变方向的边最少。

输出最少需要改变方向的边数

输出可以作为首都的编号

树形DP

先假定城市1作为首都

令tree(i)表示以i为根的子树

dp[i]表示在tree(i)中，若以i为首都的话，需要改变的边数

第一次dfs，求出dp数组

ans[i]表示在整棵树中，若以i为首都的话，需要改变的边数(注意和dp数组的意义的区别)

明显：ans[1]=dp[1]

明显有：

在一棵有向树中，若首都为u，现在我们要让u的儿子节点v为首都，只需要改变1条边的方向

假设节点u是节点v的父节点，e=(u,v),ans[u]已知

若e的方向指向v，则：ans[v]=ans[u]+1

否则：ans[v]=ans[u]-1

所以第二次dfs，递推求出ans数组

接着，找出min=min(ans[i]),并输出min

输出所有使得ans[i]==min的i

#include<cstdio>
#include<cstring>

using namespace std;

const int maxn=200000+5;

struct Edge
{
    int to,next;
    bool flag;
};
Edge edge[maxn<<1];
int head[maxn];
int tot;
int ans[maxn];
int dp[maxn];
int print[maxn];

void init()
{
    memset(head,-1,sizeof head);
    tot=0;
    memset(dp,0,sizeof dp);
}

void addedge(int u,int v,bool flag)
{
    edge[tot].to=v;
    edge[tot].flag=flag;
    edge[tot].next=head[u];
    head[u]=tot++;
}

void dfs0(int ,int );
void dfs1(int ,int );

int main()
{
    int n;
    init();
    bool cnt=true;
    scanf("%d",&n);
    for(int i=1;i<n;i++)
    {
        int u,v;
        scanf("%d %d",&u,&v);
        addedge(u,v,cnt);
        addedge(v,u,!cnt);
    }
    dfs0(1,-1);
    ans[1]=dp[1];
    dfs1(1,-1);

    int min=ans[1];
    for(int i=2;i<=n;i++)
    {
        if(ans[i]<min)
            min=ans[i];
    }
    tot=1;
    for(int i=1;i<=n;i++)
    {
        if(ans[i]==min)
        {
            print[tot++]=i;
        }
    }

    printf("%d
",min);
    for(int i=1;i<tot-1;i++)
    {
        printf("%d ",print[i]);
    }
    printf("%d
",print[tot-1]);

    return 0;
}

void dfs0(int u,int pre)
{
    for(int i=head[u];~i;i=edge[i].next)
    {
        int v=edge[i].to;
        bool flag=edge[i].flag;
        if(v==pre)
            continue;
        dfs0(v,u);
        if(flag)
            dp[u]+=dp[v];
        else
            dp[u]+=(dp[v]+1);
    }
    return ;
}

void dfs1(int u,int pre)
{
    for(int i=head[u];~i;i=edge[i].next)
    {
        int v=edge[i].to;
        int flag=edge[i].flag;
        if(v==pre)
            continue;
        if(flag)
            ans[v]=ans[u]+1;
        else
            ans[v]=ans[u]-1;
        dfs1(v,u);
    }
    return ;
}