poj 1463Strategic game【树形dp】_c++ 实现城市拓扑图的输入和城市间邻接矩阵的显示-优快云博客

本文链接：https://blog.youkuaiyun.com/u014427196/article/details/50775463

本文介绍了一种使用树形动态规划解决最小点覆盖问题的方法。通过递归地计算每个节点选择与否的成本，最终得到覆盖整棵树所需的最少点数。代码实现包括了节点结构定义、初始化、添加边及深度优先搜索等关键步骤。

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

题意：给你一棵树，求用最小的点覆盖所有的边。

思路：
树上的dp,对于一个节点i，dp[i][1]表示以i为根节点选择i点的最优解,dp[i][0]为不选择i的解，对于所有的j是i的儿子节点，dp[i][0] += dp[j][1],dp[i][1] += min(dp[j][1],dp[j][0]);

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <string.h>
#include <string>

using namespace std;

struct Edge
{
    int to, next;
}edge[5010000];

int tol = 0;
int head[2010];

void init()
{
    memset(head, -1, sizeof(head));
}

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

int n, vis[2010];
int dp[2010][2];

void dfs(int root)
{
    dp[root][0] = 0;
    dp[root][1] = 1;

    if (vis[root])
        return;
    vis[root] = 1;

    for (int i = head[root];i != -1;i = edge[i].next)
    {
        int v = edge[i].to;
        if (!vis[v])
        {
            dfs(v);
            dp[root][0] += dp[v][1];
            dp[root][1] += min(dp[v][0], dp[v][1]);
        }
    }
}

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        init();
        int root;
        memset(dp, 0, sizeof(dp));
        memset(vis, 0, sizeof(vis));

        for (int i = 1;i <= n;i++)
        {
            int m, v, num;
            scanf("%d:(%d)", &m, &num);

            if (i == 1) root = m;

            while (num--)
            {
                scanf("%d", &v);
                addedge(m, v);
                addedge(v, m);
            }
        }

        dfs(root);

        int ans = min(dp[root][0], dp[root][1]);
        printf("%d\n", ans);
    }
    return 0;
}