acwing28树形DP

已于 2022-07-26 08:14:31 修改
阅读量99 收藏
点赞数
分类专栏： 笔记 文章标签： 动态规划 c++ 算法
于 2021-11-23 19:43:17 首次发布
原文链接：https://blog.csdn.net/messywind/article/details/117473606?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163766446516780271937263%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=163766446516780271937263&biz_id
版权

树形DP板子题：

树的直径和距离：
1072. 树的最长路径
直径：

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=2e5+10;
int ne[N],h[N];
int e[N],idx;
int w[N];
int ans;
int dfs(int u,int father)
{
    int dist=0;
    int d1=0;int d2=0;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==father) continue;
        int d=dfs(j,u)+w[i];//每一个子树的尺寸
        dist=max(d,dist); //求子树的最大值用于Return
        if(d>d1)  d2=d1,d1=d;//对每一个子树求最长和次长尺寸
        else if(d>d2) d2=d;
    } 

    ans=max(ans,d1+d2);//全局找最长路径
    return dist;
}
void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int n;
int main()
{
    memset(h,-1,sizeof h);
    cin>>n;
    for(int i=1;i<n;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    dfs(1,0);
    cout<<ans<<endl;
}

1073. 树的中心
树上两点最大距离：

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N = 4e5 + 10;
int ne[N] , w[N] , e[N] , h[N] , idx , ans = 0x3f3f3f3f;
int dist[N][3] , n , up[N];
void add(int a, int b , int c)
{
	e[idx] = b , ne[idx] = h[a] , w[idx] = c , h[a] = idx ++;
}
int dfs1(int u , int father)
{
	int d1 = 0 , d2 = 0;
	for(int i = h[u] ; ~ i ; i = ne[i])
	{
		int j = e[i];
		if(j == father)  continue;
		int now = dfs1(j , u) + w[i];
		if(now > d1)
		{
			d2 = d1;
			d1 = now;
		}
		else if(now > d2)
		{
			d2 = now;
		}
	}
    dist[u][1] = d1 , dist[u][2] = d2;
	return dist[u][1];
}
void dfs2(int u , int father)
{
	for(int i = h[u] ; ~ i ; i = ne[i])
	{
		int j = e[i];
		if(j == father)  continue;
		up[j] = up[u] + w[i];
		if(dist[u][1] == dist[j][1] + w[i])
		{
			up[j] = max(up[j] , dist[u][2] + w[i]);
		}
		else
		{
		    up[j] = max(up[j] , dist[u][1] + w[i]);
		}
		dfs2(j , u);
	}
}
signed main()
{
	memset(h , -1 , sizeof h);
	cin >> n;
	for(int i = 1 ; i <= n - 1 ; i ++)
	{
		int a , b , c;
		scanf("%lld %lld %lld" , &a , &b , &c);
		add(a , b , c) , add(b , a , c);
	}
	dfs1(1 , -1);
	dfs2(1 , -1);
	for(int i = 1 ; i <= n ; i ++)
	{
		ans = min(ans , max({dist[i][1] , up[i]}));
	}
	printf("%lld\n" , ans);
}

1075. 数字转换
在这里插入图片描述
用约束建边，本质还是求树上的直径。

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

using namespace std;

const int N = 2*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 father)  //求树的直径
{
    st[u] = true;
    int dist = 0;
    int d1 = 0, d2 = 0;
    for (int i = h[u]; i != -1; i = ne[i]) {
        int j = e[i];
        if (j == father) continue;
        if (!st[j]) {
            int d = dfs(j, u) + 1;
            dist = max(dist, d);
            if (d >= d1)
                d2 = d1, d1 = d;
            else if (d > d2)
                d2 = d;
        }
    }

    ans = max(ans, d1 + d2);

    return dist;
}

int main() {
    cin >> n;
    memset(h, -1, sizeof h);

    for (int i = 1; i <= n; i++)
        for (int j = 2; j <= n / i; j++)  //筛法求一个数的所有约数和
            sum[i * j] += i;

    for (int i = 2; i <= n; i++)
        if (sum[i] < i) {
            add(sum[i], i);  //自己的约数和向自己连一条边
            add(i, sum[i]);
        }

    dfs(1, -1);
    cout << ans << endl;
    return 0;
}

二叉苹果树
树上背包板子。

#include<bits/stdc++.h>
#define int long long
const int N = 110;
using namespace std;
int f[N][N * N] , n , m , ne[N * 2] , e[N * N] , h[N * 2] , w[N * N] , idx , siz[N * N];
void add(int a , int b , int c)
{
	e[idx] = b , ne[idx] = h[a] , w[idx] = c , h[a] = idx ++;
}
void dfs(int u , int father)
{
	f[u][0] = 0;
	for(int i = h[u] ; ~ i ; i = ne[i])
	{
		int j = e[i];
		if(j == father)  continue;
		dfs(j , u);
		siz[u] += 1;
		for(int k = siz[u]; k >= 0 ; k --)
		{
			for(int z = siz[j] ; z >= 0 ; z --)
			{
			 	f[u][k + z] = max(f[u][k + z] , f[u][k - 1] + f[j][z] + w[i]);
			}
		}
		siz[u] = (siz[u] + siz[j]);
	}
}
signed main()
{
	cin >> n >> m;
	memset(h , -1 , sizeof h);
	memset(f , -0x3f , sizeof f);
	for(int i = 1 ; i < n ; i ++)
	{
		int  a , b , c;
		scanf("%lld %lld %lld" , &a , &b , &c);
		add(a , b , c);
		add(b , a , c);
	}
	dfs(1 , -1);
	cout << f[1][m] << endl;
}

P1352 没有上司的舞会
最大独立集。
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=1e5+10;
int n,ans,f[N][3];
int ne[N],e[N],w[N],h[N],idx;
int has_root[N];
void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void dfs(int x)
{
    f[x][1]=w[x];
    for(int i=h[x];i!=-1;i=ne[i])
    {
        int j=e[i];
        dfs(j);
        f[x][1]+=f[j][0];
        f[x][0]=f[x][0]+max(f[j][1],f[j][0]);
    }
}
signed main()
{
    memset(h,-1,sizeof h);
    cin>>n;
    for(int i=1;i<=n;i++)  cin>>w[i];
    for(int i=1;i<=n-1;i++)
    {
        int l,k;
        cin>>l>>k;
        has_root[l]=1;
        add(k,l);
    }
    int root=1;
    while(has_root[root]) root++;
    dfs(root);
    cout<<max(f[root][0],f[root][1])<<endl;
}

最小点覆盖
选最少的点覆盖所有的边。
323. 战略游戏
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
const int N=1510;
int dp[N][3],st[N],n;
int ne[N],e[N],h[N],idx;
void add(int a, int b)  // 添加一条边a->b
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
int dfs(int x)
{
    dp[x][1]=1;
    for(int i=h[x];i!=-1;i=ne[i])
    {
        int j=e[i];
        dfs(j);
        dp[x][0]+=dp[j][1];
        dp[x][1]+=min(dp[j][0],dp[j][1]);
    }
}
int main()
{
    while(cin>>n)
    {
        idx=0;
        memset(h,-1,sizeof h);
        memset(dp,0,sizeof dp);
        memset(st,0,sizeof st);
        int a,cnt;
        for(int i=1;i<=n;i++)
        {
        scanf("%d:(%d)",&a,&cnt);
        while(cnt--)
        {
            int x;
            cin>>x;
            add(a,x);
            st[x]=true;
        }    
        }
        
        int root=0;
        while(st[root])  root++;
        dfs(root);
        printf("%d\n",min(dp[root][1],dp[root][0]));
    }
}

最小支配集
1077. 皇宫看守
选出最少的点 , 使得每个点要么被选 、要么被它的相邻点支配。
在这里插入图片描述

#include<bits/stdc++.h>
#define int long long
const int N = 3010;
using namespace std;
int ne[N] , e[N] , h[N] , w[N] , idx;
int f[N][5] , siz[N] , n;
void add(int a , int b)
{
    e[idx] = b , ne[idx] = h[a] , h[a] = idx ++;
}
void dfs(int u , int father)
{
    int sum = 0 ,flag = 0;
    f[u][0] = w[u];
    // cout <<" u = " << u <<" w_u = " << w[u] << endl;
    for(int i = h[u] ; ~ i ; i = ne[i])
    {
        int j = e[i];
        if(j == father)  continue;
        flag = 1;
        dfs(j , u);
        sum += min(f[j][0] , f[j][2]);
        f[u][0] += min({f[j][0] , f[j][1] , f[j][2]});
    }
    f[u][1] = sum;
    for(int i = h[u] ; ~ i ; i = ne[i])
    {
        int j = e[i];
        if(j == father)  continue;
        f[u][2] = min(f[u][2] , f[j][0] + sum - min({f[j][0]  , f[j][2]}));
    }
   if(!flag)  f[u][1] = 0;
}
signed main()
{
    cin >> n;
    memset(h , -1 , sizeof h);
    memset(f  , 0x3f , sizeof f);
    for(int i = 1 ; i <= n ; i ++)
    {
        int x , k , r;
        scanf("%lld" , &x);
        scanf("%lld" , &w[x]);
        scanf("%lld" , &k);
        while(k --)
        {
            scanf("%lld" , &r);
            add(x , r);
            add(r , x);
        }
    }
    dfs(1 , -1);
    printf("%lld\n" , min({f[1][0] , f[1][2]}));
}
/*
6
1 30 3 2 3 4
2 16 2 5 6
3 5 0
4 4 0
5 11 0
6 5 0
*/

P2052 [NOI2011] 道路修建

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 2e6+10;
int ne[N],e[N],h[N],w[N],idx;
int siz[N],ans,n;
void add(int a,int b,int c)
{
    e[idx]=b,ne[idx]=h[a],w[idx]=c,h[a]=idx++;
}
int dfs(int u,int father)
{
    siz[u]=1;
    for(int i=h[u];~i;i=ne[i])
    {
        int j=e[i];
        if(j==father)  continue;
        dfs(j,u);
        siz[u]+=siz[j];
        ans+=abs(n-2*siz[j])*w[i];
    }
}
signed main()
{
    memset(h, -1, sizeof h);
    cin>>n;
    for(int i=1;i<=n-1;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    dfs(1,-1);
    cout<<ans<<endl;
}
波风一一水门
关注
专栏目录
AcWing 1073：树的中心 ← 树形DP
hnjzsyjyj的专栏
07-09 2056
树形 DP 常用的数组： d1[u]：从当前结点 u 向下走的最长路径长度 d2[u]：从当前结点 u 向下走的次长路径长度 up[u]：从当前结点 u 向上走的最长路径长度 p1[u]：从当前结点 u 向下走的最长路径是从哪个结点开始的 p2[u]：从当前结点 u 向下走的次长路径是从哪个结点开始的
树形DP——AcWing 323. 战略游戏
u014114223的博客
06-28 1985
树形 DP 是在树上进行的动态规划。由于树固有的递归性质，树形 DP 一般都是递归进行的。
AcWing 1075：数字转换 ← 树形DP
hnjzsyjyj的专栏
07-10 600
d1[u]:从当前结点 u 向下走的最长路径长度 d2[u]:从当前结点 u 向下走的次长路径长度 up[u]:从当前结点 u 向上走的最长路径长度 p1[u]:从当前结点 u 向下走的最长路径是从哪个结点开始的 p2[u]:从当前结点 u 向下走的次长路径是从哪个结点开始的
AcWing 1080：骑士 ← 树形DP+基环树
hnjzsyjyj的专栏
07-25 816
环形结构上的动态规划问题，是一种特殊的区间动态规划问题。 由于存在“环形后效性”，所以不满足动态规划算法的“无后效性”约束条件。故常将环形结构上的动态规划问题，通过“断环为链”策略转化为线性动态规划问题求解。所谓“无后效性”，即“未来与过去无关”。所谓“断环为链”策略，即“把环断开为链，然后复制一倍接在末尾”。
AcWing 树形DP——285. 没有上司的舞会
a131529的博客
09-02 157
【代码】AcWing 树形DP——285. 没有上司的舞会。
acwing 1073 树的中心 （树形DP）
qq_44791484的博客
03-13 149
题面 题解 我们要枚举每个点到其它点的最远距离，那么就会有两种情况，向上走或者是向下走 假设我们枚举u点，向下走 dfs_down(u) 更新当前节点向下走，叶子节点不需要更新 d1[u] 表示 u点向下的最长路径，d2[u] 表示 u 点向下的次长路径 ，p1[u] 表示 u 的向下最长路径经过的子节点 。 那么我们只要每次枚举u节点的儿子，然后更新即可 向上走：dfs_up 传入 u 节点， 我们更新它的每一个儿子（因为开始传入的u是根节点不需要向上更新） 对于u的儿子 j ，第一步肯定
acwing 1072 树的最长路径 （树形DP）
qq_44791484的博客
03-12 182
题面 题解 对于没有边权的树的直径的定义是路径上经过的边数最多 代码
AcWing 1078. 旅游规划 树形dp 树的直径
Alkali!的博客
04-03 446
题目 思路 这题其实就是给我们一棵树，让我们求出所有落在树的直径上的点的坐标。 因为树的直径可能有多条，所以这里所求的点所在的可能路径也不止一条。 那么树的直径该怎么求呢？ 可以先求出以每个结点为根，它向下伸展所能到达的所有路径长度的最大值和次大值，把这两者加起来，遍历所有点的这个属性，其中最大的这个属性便是直径。 注意，这里我们只要求向下伸展，不走回头路，不然会重复的。 int h[N], e[M], ne[M], idx; int d1[N], d2[N], p1[N], up[N]; int
acwing 1075 数字转换 （树形DP）
qq_44791484的博客
03-13 154
题面 题解 首先，对于小于n的每个数，我们可以确定它的约数之和（不包括自己）是固定的，就像4的约数之和一定是3，不可能是其他的，那么我们就可以将2-n的每个数的约数之和求出sum[i]，对于sum[i]<i 的我们连一条sum[i]---->i 的边（因为对于每个i，sum[i]是唯一确定的），也就是说每个儿子都有唯一一个父节点，那么我们最终就会构成森林（多课树），题中找最长的变换步骤就转换成了求树的最长直径 为什么不从1开始 ，因为1除本身外约数之和就是0，题中要求最小为1，所以
【AcWing算法提高课】1.7树形DP
m0_71477690的博客
09-02 261
AcWing算法提高课 1.7树形DP
树形dp入门
m0_62021646的博客
06-11 752
目录 2.最大独立集 2.1 最大独立集的定义 独立集是指图 G 中两两互不相邻的顶点构成的集合。最大独立集是具有最大尺寸的独立集。 2.2例题 没有上司的舞会 题目链接AcWing算法基础课 285.没有上司的舞会 2.3思路 本道题是有向图，由上司指向职员。用动态数组去存储图的边。has_fa[i]表示i是否有父节点，1为有，0为没有。 构造两个状态0,1。f[i][0]表示不选择i点时，i点及其子树能得到的最大快乐指数。f[i][1]表示选择i点时，i点及其子树能得到的最大快乐指数。j为i的儿子节点
AcWing 树形DP相关问题 1074. 二叉苹果树
皓首不倦 不负少年
08-03 178
import sys sys.stdin = open('data.txt', 'r') N, Q = map(int, input().split()) link = {} for i in range(1, N): a, b, w = map(int, input().split()) if a not in link: link[a] = [] if b not in link: link[b] = [] link[a].a..
AcWing 树形DP相关问题 1075. 数字转换
皓首不倦 不负少年
08-03 229
import sys sys.stdin = open('data.txt', 'r') ''' 树形DP, 树的最长路径的应用, 求一个森林里面所有树的最长路径的最大值 ''' N = int(input()) # 先求所有值的约数 factor = {} for i in range(1, N+1): for j in range(2, N // i + 1): # 约数不能是自己，所以从2开始枚举，如果约数可以是自己，从1开始枚举 if i*j not in fact.
acwing 746.树的重心（树形dp）
Onebelieve_lxl的博客
01-11 264
传送门 描述 给定一颗树，树中包含n个结点（编号1~n）和n-1条无向边。 请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。 重心定义：重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。 输入格式 第一行包含整数n，表示树的结点数。 接下来n-1行，每行包含两个整数a和b，表示点a和点b之间存在一条边。 输出格式 输出一个...
【C++初阶】：C++入门，引用概念及其性质
书山有路勤为径，学海无涯苦作舟。
09-10 1160
是的，你没看错，引用不仅可以做函数的参数，还可以做函数的返回值，我们之前写的具有返回值的函数返回的并不是直接将函数中的变量，而是返回的变量的一份临时拷贝，而拷贝是需要付出一定代价的，这样会降低我们代码的效率，但是如果我们用引用返回的话就可以避免拷贝的代价，在对程序性能要求高且允许使用引用的情况下，尽量使用引用返回。除了上述情况，引用的类型不同也会导致编译不同过，这是因为在发生类型转化的过程中，会产生临时变量，而临时变量具有常性，和常量一样，需要用。一个变量被引用后，可以继续被引用，也可以引用变量的引用。
【C++ 面试 - 新特性】每日 3 题（九）
Newin2020的博客
09-10 652
✍个人博客：Pandaconda-CSDN博客📣专栏地址：http://t.csdnimg.cn/fYaBd📚专栏简介：在这个专栏中，我将会分享 C++ 面试中常见的面试题给大家~
学懂C++（五十八）：深入详解 C++ COM编程开发技术
最新发布
martian665的专栏
09-11 1226
学懂C++：深入详解 C++ COM编程开发技术
Linux 下 C/C++ 程序编译的过程
Teminator_的博客
09-08 9554
本文将介绍如何将 C/C++ 语言编写的程序转换成为处理器能够执行的二进制代码的过程，包括四个步骤：预处理（）编译（）汇编（）链接（在此之前，首先来看一下 GCC 工具链。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值