CF_D. Choosing Capital for Treeland_树形DP

最新推荐文章于 2020-04-03 19:42:30 发布

smmrSangria

最新推荐文章于 2020-04-03 19:42:30 发布

阅读量321

点赞数

CC 4.0 BY-SA版权

分类专栏： DP 文章标签： cf D. Choosing Capital dp 树形dp 动态规划

本文链接：https://blog.youkuaiyun.com/Anna__1997/article/details/78010932

DP 专栏收录该内容

21 篇文章

订阅专栏

本文介绍了一种基于树形结构的动态规划算法，用于解决树中有向边的问题，旨在找到最小化边翻转次数的方案。通过两次深度优先搜索（DFS），算法能够有效地更新每个节点所需的翻转数量。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#define INF 0x3f3f3f3f
#define rep0(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define rep_0(i, n) for (int i = n - 1; i >= 0; i--)
#define rep_1(i, n) for (int i = n; i > 0; i--)
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#define mem(x, y) memset(x, y, sizeof(x))
/**
题目大意
树中的边为有向边 求其中的节点能到达树上的其他各节点而
需要翻转的有向边的数量最少
思路
第一次dfs 由子节点更新父亲节点 在子树内需要反转的边数
再由父节点跟新子节点的dp 如果父子之间的边指向父亲 
则 dp[i] = dp[fa] - 1;
else
    dp[i] = dp[fa] + 1;
*/

using namespace std;
const int MAXN = 2e5 + 10;
struct Edge
{
    int from, to;
    Edge(int f, int t): from(f), to(t) {}
};
vector<Edge> edges;
int dp[MAXN];
vector<int> g[MAXN];
void addEdge(int from, int to)
{
    edges.push_back(Edge(from, to));
    int sz = edges.size();
    g[from].push_back(sz - 1);
    g[to].push_back(sz - 1);


}
void dfs(int u, int fa)
{

    for (int i = 0; i < g[u].size(); i++)
    {
        Edge e = edges[g[u][i]];

        if (e.from == fa || e.to == fa)
            continue;
        if (e.to == u)
        {
            dfs(e.from, u);

            dp[u] += dp[e.from] + 1;


        }
        else
        {
            dfs(e.to, u);
            dp[u] += dp[e.to];
        }


    }
}
int ans = INF;
void dfs1(int u, int fa)
{
    for (int i = 0; i < g[u].size(); i++)
    {
        Edge e = edges[g[u][i]];
        if (e.from == fa || e.to == fa)
            continue;
        if (e.to == u)
        {
            dp[e.from] = dp[u] - 1;
            ans = MIN(ans, dp[e.from]);
            dfs1(e.from, u);
        }
        else
        {

            dp[e.to] = dp[u] + 1;
            ans = MIN(ans, dp[e.to]);
            dfs1(e.to, u);
        }

    }
}
int main()
{
    #ifndef ONLINE_JUDGE
        freopen("in.txt", "r", stdin);
    #endif // ONLINE_JUDGE;
    int n, s, t;
    scanf("%d", &n);
    mem(dp, 0);
    rep0(i, n - 1)
    {
        scanf("%d %d", &s, &t);
        addEdge(s, t);
    }
    dfs(1, -1);
    ans = MIN(ans, dp[1]);
    dfs1(1, -1);
   
    printf("%d\n", ans);
    int i = 1;
    while (dp[i] != ans)
        i++;
    printf("%d", i);

    for (i++; i <= n; i++)
        if (dp[i] == ans)
            printf(" %d", i);
    printf("\n");

    return 0;
}