算法提高之动态规划：树形dp

已于 2022-01-22 21:12:15 修改
阅读量1.7k 收藏 1
点赞数
分类专栏： 算法提高 文章标签： 算法 动态规划 c++
于 2022-01-05 21:19:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37448336/article/details/122332357
版权
本文介绍了树的最长路径（直径）的计算方法，包括向下深度优先搜索（DFS）与向上回溯（DFS），以及应用实例如二叉苹果树的背包问题和战略游戏中的决策策略。同时涵盖了树的中心节点确定和数字转换中的路径优化。
摘要由CSDN通过智能技术生成

这里写自定义目录标题

1、树的最长路径(树的直径)

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 10010, M = N * 2, INF = 0x3f3f3f3f;

int n;
int h[N], e[M], w[M], ne[M], idx;
//d1表示向下走的最长路径  d2表示向下走的次长路径 up表示向上走的最长路径
//p1存储最大值和次大值是从哪个边上来的 需要判断父节点的最长边是不是从当前子树上来的
int d1[N], d2[N], p1[N], up[N];
//当某个节点是叶子节点的时候 记为true
bool is_leaf[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

//向下dfs 
int dfs_d(int u, int father)
{
    //求最长距离和次长距离，其中次长距离是为祥上深搜做准备的
    d1[u] = d2[u] = -INF;
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (j == father) continue;
        
        //dfs_d(1,7)  p1[1]=2;
        int d = dfs_d(j, u) + w[i];
        //对于父节点由很多个子节点，一个子节点对应一个d
        //d1[u] 是对父节点而言，所有子节点中最大的d
        //d2[u] 是对父节点而言，所有子节点中次大的d
        if (d >= d1[u])
        {
            d2[u] = d1[u], d1[u] = d;
            //u是父节点，j是子节点。对于父节点，最长距离是由哪个子节点产生的
            p1[u] = j;
        }
        else if (d > d2[u]) d2[u] = d;
    }
	//是一个叶子节点
    if (d1[u] == -INF)
    {
        d1[u] = d2[u] = 0;
        is_leaf[u] = true;
    }
	//返回最长路径的长度
    return d1[u];
}

//向上dfs

void dfs_u(int u, int father)
{
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (j == father) continue;
        
        //1.dfs_u中处理向下走
        //p1[u]=j 记录的是再dfs_d中 
        //在父节点u处的最长路径是从j这个子节点过来的
		//因此在dfs_u中不能与dfs_d重复  则只能从次大值和up[u]更新
        if (p1[u] == j) up[j] = max(up[u], d2[u]) + w[i];
        else up[j] = max(up[u], d1[u]) + w[i];
        //2.dfs_u中处理向上走
        dfs_u(j, u);
    }
}

int main()
{
    cin >> n;
    memset(h, -1, sizeof h);
    for (int i = 0; i < n - 1; i ++ )
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c), add(b, a, c);
    }
    //将1号节点定义为根节点
	//向下走的最长距离和次长距离
    dfs_d(1, -1);
    //向上走的最长距离
    dfs_u(1, -1);
    
	//枚举每一个点
	//根节点向下走，叶子节点向上走。
    int res = d1[1];
    for (int i = 2; i <= n; i ++ )
        if (is_leaf[i]) res = min(res, up[i]);
        else res = min(res, max(d1[i], up[i]));

    printf("%d\n", res);

    return 0;
}

2、树的中心

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 10010, M = N * 2, INF = 0x3f3f3f3f;

int n;
int h[N], e[M], w[M], ne[M], idx;
//d1表示向下走的最长路径  d2表示向下走的次长路径 up表示向上走的最长路径
//p1存储最大值和次大值是从哪个边上来的 需要判断父节点的最长边是不是从当前子树上来的
int d1[N], d2[N], p1[N], up[N];
bool is_leaf[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

int dfs_d(int u, int father)
{
    d1[u] = d2[u] = -INF;
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (j == father) continue;
        int d = dfs_d(j, u) + w[i];
        if (d >= d1[u])
        {
            d2[u] = d1[u], d1[u] = d;
            p1[u] = j;
        }
        else if (d > d2[u]) d2[u] = d;
    }
	//是一个叶子节点
    if (d1[u] == -INF)
    {
        d1[u] = d2[u] = 0;
        is_leaf[u] = true;
    }
	//返回最长路径的长度
    return d1[u];
}

void dfs_u(int u, int father)
{
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (j == father) continue;
		//从u这个节点过来  只能从次大值更新
        if (p1[u] == j) up[j] = max(up[u], d2[u]) + w[i];
        else up[j] = max(up[u], d1[u]) + w[i];

        dfs_u(j, u);
    }
}

int main()
{
    cin >> n;
    memset(h, -1, sizeof h);
    for (int i = 0; i < n - 1; i ++ )
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c), add(b, a, c);
    }
	//向下走的最长距离和次长距离
    dfs_d(1, -1);
    //xiang
    dfs_u(1, -1);
	//枚举每一个点
    int res = d1[1];
    for (int i = 2; i <= n; i ++ )
        if (is_leaf[i]) res = min(res, up[i]);
        else res = min(res, max(d1[i], up[i]));

    printf("%d\n", res);

    return 0;
}

3、数字转换(树的最长路径)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 50010, M = N;

int n;
int h[N], e[M], w[M], ne[M], idx;
//存的是约数之和
int sum[N];
bool st[N];
int ans;

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

int dfs(int u)
{
 
    int d1 = 0, d2 = 0;
    for (int i = h[u]; i!=-1; i = ne[i])
    {
       int j = e[i];
       int d = dfs(j)+1;
       if (d >= d1) d2 = d1, d1 = d;
       else if (d > d2) d2 = d;
       
    }

    ans = max(ans, d1 + d2);
    return d1;
}

int main()
{
    cin >> n;
    memset(h, -1, sizeof h);
	//i 约数
    for (int i = 1; i <= n; i ++ )
    	//写成j*i<=n 当j和i接近int的最大范围时，可能会溢出
    	//j倍数 j!=1是因为 x的约数之和不包含本身
        for (int j = 2; j <= n / i; j ++ )
            sum[i * j] += i;
	//判断约数之和是否小于数的本身  
	//i!=1 sum[i]=0 所有数字变换在不超过n的正整数范围内进行。正整数 
    for (int i = 2; i <= n; i ++ )
    	//如果是，以约数之和为父节点，约数为子节点，建立一条有向边    
        if (sum[i] < i)
        {
            add(sum[i], i);
            st[i]=true;
        }
	//有多棵树 只需要遍历树根（没有被标记过的就是树根）
    for (int i = 1; i <= n; i ++ )
        if (!st[i])
            dfs(i);

    cout << ans << endl;

    return 0;
}

4、二叉苹果树(完全二叉树 有依赖的背包问题)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110, M = N * 2;

int n, m;
int h[N], e[M], w[M], ne[M], idx;
int f[N][N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

void dfs(int u, int father)
{
    for (int i = h[u]; ~i; i = ne[i])
    {
        if (e[i] == father) continue;
        dfs(e[i], u);
        //分组背包问题
        //e[i]物品组
        //体积 从大到小枚举
        //假设对于最后的叶子节点，依然按照m枚举，如果使用时超出m的范围
        //忽略不用即可
        for (int j = m; j>=0; j -- )
        	//决策 每一个子树的选择方式
            for (int k = 0; k + 1 <= j; k ++ )
            //f[u][j] 以u为根的子树中，选j条边的最大价值
                f[u][j] = max(f[u][j], f[u][j - k - 1] + f[e[i]][k] + w[i]);
    }
}

int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 0; i < n - 1; i ++ )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c), add(b, a, c);
    }

    dfs(1, -1);
	//以1为根的子树中，选择m条边。剩余苹果的最大价值
    printf("%d\n", f[1][m]);

    return 0;
}

5、战略游戏

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1510;

int n;
int h[N], e[N], ne[N], idx;
int f[N][2];
//判断父节点
bool st[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void dfs(int u)
{
//f[u][1] = 1 当前位置放上士兵就说明耗费1
//f[u][0]=0 是为了清空。多组测试数据 之前可能使用了f[u][0]
    f[u][0] = 0, f[u][1] = 1;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        dfs(j);
        f[u][0] += f[j][1];
        f[u][1] += min(f[j][0], f[j][1]);
    }
}

int main()
{
    while (cin >> n)
    {
    //多组测试数据  清空 头结点h  下标idx
        memset(h, -1, sizeof h);
        idx = 0;
	//清空父节点标记
        memset(st, 0, sizeof st);
        for (int i = 0; i < n; i ++ )
        {
            int id, cnt;
            scanf("%d:(%d)", &id, &cnt);
            while (cnt -- )
            {
                int ver;
                cin >> ver;
                add(id, ver);
                //ver有父节点
                st[ver] = true;
            }
        }

        int root = 0;
        while (st[root]) root ++ ;
        dfs(root);

        printf("%d\n", min(f[root][0], f[root][1]));
    }

    return 0;
}

6、皇宫看守

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1510;

int n;
int h[N], w[N], e[N], ne[N], idx;
int f[N][3];
bool st[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void dfs(int u)
{
    f[u][2] = w[u];
	//所有子节点f[j][1]和f[j][2]最小值的和
	//f[i][1]计算时需要除了被选的子节点之外的所有节点f[j][1]和f[j][2]的最小值之和
	//使用sum-k的就等于除k节点之外的其他节点f[j][1]和f[j][2]的最小值之和
    int sum = 0;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        dfs(j);
        f[u][0] += min(f[j][1], f[j][2]);
        f[u][2] += min(min(f[j][0], f[j][1]), f[j][2]);
        sum += min(f[j][1], f[j][2]);
    }

    f[u][1] = 1e9;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        f[u][1] = min(f[u][1], sum - min(f[j][1], f[j][2]) + f[j][2]);
    }
}

int main()
{
    cin >> n;

    memset(h, -1, sizeof h);
    for (int i = 1; i <= n; i ++ )
    {
        int id, cost, cnt;
        cin >> id >> cost >> cnt;
        w[id] = cost;
        while (cnt -- )
        {
            int ver;
            cin >> ver;
            add(id, ver);
            st[ver] = true;
        }
    }

    int root = 1;
    while (st[root]) root ++ ;

    dfs(root);
	//根节点被子节点看到，或者根节点上有守卫 根节点不可能有父节点
    cout << min(f[root][1], f[root][2]) << endl;

    return 0;
}

解释sum的用处
在这里插入图片描述
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1510;

int n;
int h[N], w[N], e[N], ne[N], idx;
int f[N][3];
bool st[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

//不写sum的写法
void dfs(int u)
{
    f[u][2] = w[u];
    
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        dfs(j);
        f[u][0] += min(f[j][1], f[j][2]);
        f[u][2] += min(min(f[j][0], f[j][1]), f[j][2]);
       
    }

    f[u][1] = 1e9;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        f[u][1] = min(f[u][1], f[u][0] - min(f[j][1], f[j][2]) + f[j][2]);
    }
}

int main()
{
    cin >> n;

    memset(h, -1, sizeof h);
    for (int i = 1; i <= n; i ++ )
    {
        int id, cost, cnt;
        cin >> id >> cost >> cnt;
        w[id] = cost;
        while (cnt -- )
        {
            int ver;
            cin >> ver;
            add(id, ver);
            st[ver] = true;
        }
    }

    int root = 1;
    while (st[root]) root ++ ;

    dfs(root);

    cout << min(f[root][1], f[root][2]) << endl;

    return 0;
}
素位明哲
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划——树形dp
qq_57150526的博客
01-03 3170
树形 DP，即在树上进行的 DP。由于树固有的递归性质，树形 DP 一般都是递归进行的。在树上设计动态规划算法时，一般就以节点从深到浅（子树从小到大）的顺序作为DP的“阶段”，DP的状态表示中，第一维通常是节点编号（代表以该节点为根的子树）。自底向上dfs，属于树的后序遍历
动态规划（树形dp）
dzy521的博客
07-04 743
#### 四、树形dp ##### （一）、基础 树形$dp$是在树的$dfs$中进行$dp$， 在树形$dp$中，我们动态规划的过程大概就是先递归访问所有子树，再在根上合并，我们求解的往往是所有的在子树范围内的最优解 ##### （二）、例题 1、子树大小 （1）、题意：计算每个点的子树的大小 （2）、题解： 状态表示：$sz[u]$代表$u$为根的子树大小 状态转移：$sz[u]=1+\sum sz[v]$，指本节点的子树大小等于子节点的所有子树大小之和加一 ```cpp int sz
动态规划 树形DP
weixin_52621204的博客
05-18 226
P1352 没有上司的舞会，Strategic game，P3478 [POI2008] STA-Station，P2014 [CTSC1997] 选课，P3478 [POI2008] STA-Station，P2986 [USACO10MAR] Great Cow Gathering G - 洛谷，二叉苹果树，Rinne Loves Edges，吉吉王国
动态规划：树形DP
sdfzhqy的博客
01-14 434
动态规划：树形dp
动态规划 —— 树形DP
qq_45949914的博客
10-02 2475
【概述】 树形动态规划是在树的数据结构上的动态规划，在各个阶段呈现树状关系的时候可以采用树形 DP，其基本思想是由子节点的信息推出父节点的信息。 树形 DP 中，是通过以下 4 点树的特点来进行建图的： n 个点，n-1 条边的无向图，任意两顶点间可达 无向图中任意两个点间有且只有一条路 一个点至多有一个前趋，但可以有多个后继 无向图中没有环 【计算顺序】 计算顺序与线性动态规划的顺推、逆推相似，同样有两个方向： 叶 => 根：在回溯时，从叶节点向上转移状态 根 => 叶：在叶向根 DFS
树形DP（动态规划）.pptx
01-12
树形动态规划（Tree Dynamic Programming, 简称树形DP）是一种在树结构上进行优化决策的方法，常用于解决与树形结构相关的最优化问题。在这个特定的问题中，我们面临的是一个聚会组织的问题，目标是找到使得幽默系数...
算法-动态规划- 树形 DP（包含源程序）.rar
09-16
4. **源程序分析**：压缩包中的PDF文件很可能是对树形DP算法的详细讲解，可能包含了实际编程实现的示例。通过阅读这些源代码，你可以更深入地理解如何在实践中应用树形DP，包括数据结构的选择、递归或迭代的实现方式...
2021 最新 NOIP 学习课件：树形dp
03-17
树形动态规划（Tree DP），通常也被称为树形DP，是一种应用于树形结构数据上的动态规划算法。NOIP（全国青少年信息学奥林匹克竞赛）是面向中学生的计算机编程竞赛，而NOI（全国信息学奥林匹克竞赛）和OI（信息学...
动态规划（DP）-背包问题算法详解背包九讲
01-12
动态规划（DP）——背包问题算法详解[背包九讲]
算法进阶02.zip 树形dp问题
06-20
在这个压缩包“算法进阶02.zip”中，我们很可能找到了关于树形DP的深入讲解和实例。树DP通常用于处理与树结构数据相关的优化问题，例如树的最短路径、树的最大/最小权值问题等。 树形DP的核心思想是将树的节点分为...
树形动态规划（树形DP）入门问题—初探 & 训练
weixin_30814223的博客
04-29 1101
树形DP入门 poj 2342 Anniversary party 先来个题入门一下~ 题意： 某公司要举办一次晚会，但是为了使得晚会的气氛更加活跃，每个参加晚会的人都不希望在晚会中见到他的直接上司，现在已知每个人的活跃指数和上司关系（当然不可能存在环），求邀请哪些人（多少人）来能使得晚会的总活跃指数最大。 解题思路： 任何一个点的取舍可以看作一种决策，那么状态就是在某个...
动态规划之树形DP专题（附题目清单）
剑锋OI SharpSwordOI
12-14 6419
之所以这样命名树规，是因为树形DP的这一特殊性： 没有环，dfs是不会重复，而且具有明显而又严格的层数关系。 利用这一特性，我们可以很清晰地根据题目写出一个在树（型结构）上的记忆化搜索的程序。而深搜的特点，就是“不撞南墙不回头”。这一点在之后的文章中会详细的介绍。 动态规划： 　　问题可以分解成若干相互联系的阶段，在每一个阶段都要做出决策，全部过程的决策是一个决策序列。要使整个活动的总体效果...
树形动态规划（树状DP）小结
weixin_30512043的博客
04-29 1192
树状动态规划定义 之所以这样命名树规，是因为树形DP的这一特殊性：没有环，dfs是不会重复，而且具有明显而又严格的层数关系。利用这一特性，我们可以很清晰地根据题目写出一个在树（型结构）上的记忆化搜索的程序。而深搜的特点，就是“不撞南墙不回头”。这一点在之后的文章中会详细的介绍。 首先是扫盲，介绍几条名词的专业解释以显示我的高端（大部分人可以略过，因为学习到树规的人一下应该...
动态规划--树形DP
一只IT小小鸟
03-26 2775
动态规划--树形DP 1、什么是树型动态规划 顾名思义，树型动态规划就是在“树”的数据结构上的动态规划，平时作的动态规划都是线性的或者是建立在图上的，线性的动态规划有二种方向既向前和向后，相应的线性的动态规划有二种方法既顺推与逆推，而树型动态规划是建立在树上的，所以也相应的有二个方向：     1、叶－&gt;根：在回溯的时候从叶子节点往上更新信息    2、根 - &gt;叶：往往是在从叶往根d...
算法日记day 45（单调栈之每日温度|接雨水）
最新发布
m0_74980681的博客
08-22 815
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 340
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
Leetcode 219. 存在重复元素 II⭐️
铁马冰河入梦来
08-20 420
哈希表解决存在重复元素二问题
智能微气候:精准调控背后的算法革命
u010079117的博客
08-20 950
通过迁移学习,优化后的策略可快速移植到新的设施环境、新的作物品种,实现农业专家知识的规模化复用。农业知识图谱是智慧农业的基础设施。未来,LLM与5G、IoT等新一代信息技术的融合,将进一步提升设施农业的智能化水平,实现更精准、更高效、更环保的设施种植模式。另一方面,LLM可以学习农业专家的经验知识,通过知识蒸馏等技术,将专家经验转化为可解释、可迁移的计算机程序,助力农业生产智能化。温室、养殖舍等设施通过对光、温、水、气、肥等环境要素的调控,为作物和畜禽营造最适宜的生长环境,实现农业生产的高产、优质、高效。
最小区间00
青釉Oo的博客
08-21 451
最小区间
动态规划进阶：区间DP、概率DP与树形DP解析
区间DP常用于处理与区间相关的最优化问题，概率DP则涉及计算期望和概率，而树形DP则是在树结构上的动态规划算法。这些方法在处理复杂问题时能有效地降低时间复杂度，并通过递归或迭代的方式找到最优解。" 区间DP ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值