codeforces 219D 树形DP

题目链接

题意：

给一颗树但边是单向边，求至少旋转多少条单向边的方向，可以使得树有点可以到达树上任意一点，若有多个答案全部输出。 

思路：

两边dfs求解：

第一遍：

定义dp数组：dp[u]表示从上到下以u为根，至少需要旋转多少条边的方向使得根u可以到达子树中任意一点。

状态转移方程：dp[u] += dp[v]+w（若连接u,v两点的边为u->v则w为0,反之为1）

第二遍：

定义dp数组：dp[u]表示以u为根，至少需要旋转多少条边的方向使得根u可以到达子树中任意点。

状态转移方程（类似树的旋转）：dp[v] = dp[u]+w（若连接u,v两点的边为u->v则w为1,反之为-1）

C++代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 200010;
const int maxm = 400010;

int n,tol,head[maxn];
struct edge
{
    int to,next,cost;
}es[maxm];
//cost 0:正向
//cost 1:反向

void addedge( int u , int v , int w )
{
    es[tol].to = v;
    es[tol].cost = w;
    es[tol].next = head[u];
    head[u] = tol++;
}

int dp[maxn];

void dfs1( int u , int f )
{
    for ( int i=head[u] ; i!=-1 ; i=es[i].next )
    {
        int v = es[i].to,w = es[i].cost;
        if ( v!=f )
        {
            dfs1( v , u ); dp[u] += w+dp[v];
        }
    }
}

void dfs2( int u , int f )
{
    for ( int i=head[u] ; i!=-1 ; i=es[i].next )
    {
        int v = es[i].to,w = es[i].cost;
        if ( w==0 ) w = 1;  else w = -1;
        if ( v!=f )
        {
            dp[v] = dp[u]+w; dfs2( v , u );
        }
    }
}

int ans,que[maxn],len;

int main()
{
    tol = 0; memset ( head , -1 , sizeof(head) );
    scanf ( "%d" , &n );
    for ( int i=1 ; i<n ; i++ )
    {
        int u,v; scanf ( "%d%d" , &u , &v );
        addedge( u , v , 0 );
        addedge( v , u , 1 );
    }
    memset( dp , 0 , sizeof(dp) );
    dfs1 ( 1 , 0 );
    dfs2 ( 1 , 0 );
    ans = maxn; len = 0;
    for ( int i=1 ; i<=n ; i++ )
    {
        if ( dp[i]<ans )
        {
            ans = dp[i];
            que[len=1] = i;
        }
        else if ( dp[i]==ans )
        {
            que[++len] = i;
        }
    }
    printf ( "%d\n" , ans );
    for ( int i=1 ; i<=len ; i++ )
    {
        if ( i!=1 ) printf( " " );
        printf ( "%d" , que[i]  );
    }
    printf( "\n" );
    return 0;
}