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=+;

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

 void init()
 {
     memset(head,-,sizeof head);
     tot=;
     memset(dp,,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=;i<n;i++)
     {
         int u,v;
         scanf("%d %d",&u,&v);
         addedge(u,v,cnt);
         addedge(v,u,!cnt);
     }
     dfs0(,-);
     ans[]=dp[];
     dfs1(,-);

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

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

     return ;
 }

 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]+);
     }
     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]+;
         else
             ans[v]=ans[u]-;
         dfs1(v,u);
     }
     return ;
 }