树形dp题目汇总

详细算法见:https://user.qzone.qq.com/50222268/blog/1503921896

 

1.题目:https://www.luogu.org/problemnew/show/P2014#sub

如何将普通树变成兄弟二叉树:

无父节点的节点为 n+1

​
for (int i=1; i<=n; ++i) {

        int a, b;

        cin >> a >> b;

        if (a == 0)    a = n + 1;

        score[i] = b;
        brother[i] = child[a];//i节点的兄弟为其父节点a的孩子
        child[a] = i;

}


​

 

 

代码:

#include <cstdio>
#include <algorithm>
#include <cstring>

using namespace std;

struct node
{
	int wei,l,r;
};

const int maxSize=300;
int n,m;
int vis[maxSize+5][maxSize+5],f[maxSize+5][maxSize+5];
node N[maxSize+5];

void dfs(int x,int y)
{
	int i,j;
	
	if (vis[x][y]==1)//防止重复搜 
		return ;
	vis[x][y]=1;
	
	if (x==0 || y==0)
		return ;
	
	dfs(N[x].r,y);	//不选x节点
	f[x][y]=f[N[x].r][y];
	
	for (i=0;i<y;i++)//选x节点 
	{
		dfs(N[x].l,i);	//孩子节点选i个
		dfs(N[x].r,y-i-1);	//兄弟节点选y-i-1个
		f[x][y]=max(f[x][y],f[N[x].l][i]+f[N[x].r][y-i-1]+N[x].wei);
	}
}

int main()
{
	int i,x,y,ans;
	
	freopen("a.txt","r",stdin);
	scanf("%d%d",&n,&m);
	for (i=1;i<=n;i++)
	{
		scanf("%d%d",&x,&y);
		if (x==0)
			x=n+1;
		N[i].wei=y;
		N[i].r=N[x].l;
		N[x].l=i;
	}
	
	for (i=1;i<=n;i++)
		dfs(i,m);//从根节点搜起
	ans=0; 
	for (i=1;i<=n;i++)
		ans=max(ans,f[i][m]);
	printf("%d\n",ans);
	
	return 0;
}

 

2.题目:https://www.luogu.org/problemnew/show/P2015#sub

此题要注意把边权化点权

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>

using namespace std;

struct node
{
	int wei,y;
};
struct node1
{
	int l,r,wei;
};

const int maxSize=100;
int n,q;
int vis[maxSize+5],visit[maxSize+5][maxSize+5],f[maxSize+5][maxSize+5];
node1 a[maxSize+5];
vector <node> N[maxSize+5];

void read(int x)
{
	int i;
	node n1;
	
	for (i=0;i<N[x].size();i++)
	{
		n1=N[x][i];
		if (vis[n1.y]==1)
			continue;
			
		a[n1.y].wei=n1.wei;//边权变成点权 
		if (a[x].l==0)
			a[x].l=n1.y;
		else
			a[x].r=n1.y;
		
		vis[n1.y]=1;
		read(n1.y);
		vis[n1.y]=0;
	}
}

void dfs(int x,int q)
{
	int i;
	node n1;
	
	if (visit[x][q]==1)
		return ;
	visit[x][q]=1;
	
	if (x==0 || q==0)
		return ;
	for (i=0;i<q;i++)
	{
		dfs(a[x].l,i);
		dfs(a[x].r,q-i-1);
		f[x][q]=max(f[x][q],f[a[x].l][i]+f[a[x].r][q-i-1]+a[x].wei);
	}
}

int main()
{
	int i,x,y,z;
	node n1;
	
	freopen("a.txt","r",stdin);
	scanf("%d%d",&n,&q);
	
	for (i=1;i<n;i++)
	{
		scanf("%d%d%d",&x,&y,&z);
		n1.y=y;		n1.wei=z;
		N[x].push_back(n1);
		n1.y=x;
		N[y].push_back(n1);
	}
	memset(vis,0,sizeof(vis));
	memset(visit,0,sizeof(visit));
	vis[1]=1;
	read(1);
//	for (i=1;i<=n;i++)
//		printf("%d %d %d\n",a[i].l,a[i].r,a[i].wei);
	dfs(1,q+1);
	printf("%d\n",f[1][q+1]);
	
	return 0;
}

 

3.题目:https://www.luogu.org/problemnew/show/P1352#sub

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>

using namespace std;

struct node
{
	int y,wei;//wei指y的权重 
};

const int maxSize=6000;
vector <node> N[maxSize+5];
int n;
int a[maxSize+5],ru[maxSize+5],vis[maxSize+5],f[maxSize+5][2];
//f 0去 1不去 
void dfs(int x)
{
	int i,f1=0,f0=0;
	node n1;
	
	for (i=0;i<N[x].size();i++)
	{
		n1=N[x][i];
		if (vis[n1.y]==1)
			continue;
			
		vis[n1.y]=1;
		dfs(n1.y);
		vis[n1.y]=0;
		f0+=f[n1.y][1];
		f1+=max(f[n1.y][0],f[n1.y][1]);
	}
	f[x][0]=max(f[x][0],f0+a[x]);
	f[x][1]=max(f[x][1],f1);
}

int main()
{
	int i,x,y,gen;
	node n1;
	
	freopen("a.txt","r",stdin);
	scanf("%d",&n);
	for (i=1;i<=n;i++)
		scanf("%d",&a[i]);
	
	memset(ru,0,sizeof(ru));
	for (i=1;i<=n;i++)
	{
		scanf("%d%d",&x,&y);
		n1.y=x;	n1.wei=a[x];
		N[y].push_back(n1);
		ru[x]++;
	}
	for (i=1;i<=n;i++)
	{
		if (ru[i]==0)
		{
			gen=i;
			break;
		}
	}
	
	memset(vis,0,sizeof(vis));
	dfs(gen);
	printf("%d\n",max(f[gen][0],f[gen][1]));
	
	return 0;
}

 

4.完美服务器

gfoj---course---动态规划2

注意状态转移方程可以化简

写程序时方程不能特判!!!

原因:

1,此方程是递推出来的,所以不能特判

2,若不满足则直接上maxValue,此处maxValue不能过大。。。

 

代码:

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;

const int maxSize=10000,maxValue=1000000;
vector <int> N[maxSize+5];
int vis[maxSize+5],f[maxSize+5][3];

void dfs(int x)
{
	int i,y;
	
	for (i=0;i<N[x].size();i++)
	{
		y=N[x][i];
		if (vis[y]==1)
			continue;
		vis[y]=1;
		dfs(y);
		vis[y]=0;
		f[x][0]+=min(f[y][1],f[y][0]);
		f[x][1]+=f[y][2];
	}
		
	for (i=0;i<N[x].size();i++)
	{
		y=N[x][i];
		if (vis[y]==1)
			continue;
		f[x][2]=min(f[x][2],f[y][0]+f[x][1]-f[y][2]);
	}
}

int main()
{
	int i,n,x,y;
	
	freopen("a.txt","r",stdin);
	while (1)
	{
		scanf("%d",&n);
		if (n==-1)
			break;
		if (n==0)
			continue;
		
		for (i=1;i<=n;i++)
			N[i].clear();
		
		for (i=1;i<n;i++)
		{
			scanf("%d%d",&x,&y);
			N[x].push_back(y);
			N[y].push_back(x);
		}
		memset(vis,0,sizeof(vis));
		for (i=1;i<=n;i++)
		{
			f[i][0]=1;
			f[i][1]=0;
			f[i][2]=maxValue;
		}
		vis[1]=1;
		dfs(1);
		printf("%d\n",min(f[1][0],f[1][2]));
	}
	
	
	return 0;
}

 

5.寻宝:

https://blog.youkuaiyun.com/scutbenson/article/details/81738322

 

6.行动!行动!

https://blog.youkuaiyun.com/scutbenson/article/details/81745008

### 链剖分与动态规划的结合用法 链剖分是一种用于处理上路径查询和修改的技术,通过两次深度优先搜索 (DFS) 将转化为线性区间,并利用数据结构(如线段状数组)加速操作。动态规划则可以通过预处理子问的答案来减少冗余计算。两者的结合主要体现在对上的某些属性进行快速更新和查询时,使用动态规划的思想优化状态转移。 以下是具体的实现方法以及代码示例: #### 实现原理 1. **链剖分的核心** 使用两次 DFS 完成轻重边划分,将划分为若干条重链。每条重链对应一个连续的编号范围,便于后续在线段或其他数据结构中进行区间操作[^4]。 2. **动态规划的状态定义** 假设我们需要维护某种节点之间的关系(例如最大值、最小值或总和),可以定义 DP 状态 `dp[u]` 表示以节点 `u` 为根的子中的某个最优解。对于不同类题目DP 的具体含义会有所不同。 3. **状态转移方程** 利用链剖分后的父子关系,可以从父节点向子节点传递信息,或者反过来从子节点向上汇总到父节点。这种自底向上的方式非常适合动态规划的应用场景。 4. **结合线段/状数组** 如果需要频繁地对某条路径上的数值进行修改或查询,则可以在链剖分的基础上引入线段等辅助工具,进一步提升效率。 --- #### 代码示例:链剖分 + 动态规划 下面是一个典的例子——在上求路径的最大权值和。我们将结合链剖分和动态规划完成这一目标。 ```python from collections import defaultdict class TreeChainDecomposition: def __init__(self, n): self.n = n self.graph = [[] for _ in range(n)] self.parent = [-1] * n self.depth = [0] * n self.size = [0] * n self.heavy = [-1] * n self.chain_idx = [0] * n self.pos_in_base = [0] * n self.base_array = [] def add_edge(self, u, v): self.graph[u].append(v) self.graph[v].append(u) def first_dfs(self, root=0): # 计算 size 和 heavy 子节点 stack = [(root, -1)] while stack: node, prev_node = stack.pop() if prev_node != -1 and self.parent[node] == -1: self.parent[node] = prev_node self.depth[node] = self.depth[prev_node] + 1 sub_size = 0 max_subtree = -1 for child in self.graph[node]: if child != prev_node: stack.append((child, node)) sub_size += 1 if max_subtree == -1 or self.size[child] > self.size[max_subtree]: max_subtree = child self.size[node] = sub_size + 1 self.heavy[node] = max_subtree def second_dfs(self, root=0, chain_root=-1): # 给定重链索引并分配 base 数组位置 pos = len(self.base_array) self.chain_idx[root] = chain_root if chain_root != -1 else root self.pos_in_base[root] = pos self.base_array.append(root) if self.heavy[root] != -1: # 处理重儿子 self.second_dfs(self.heavy[root], self.chain_idx[root]) for child in self.graph[root]: # 非重儿子单独形成新链 if child != self.parent[root] and child != self.heavy[root]: self.second_dfs(child, child) def update_segment_tree(tree, idx, value, start, end, seg_pos=1): if start == end: tree[seg_pos] = value return mid = (start + end) // 2 if idx <= mid: update_segment_tree(tree, idx, value, start, mid, seg_pos*2) else: update_segment_tree(tree, idx, value, mid+1, end, seg_pos*2+1) tree[seg_pos] = max(tree[seg_pos*2], tree[seg_pos*2+1]) def query_segment_tree(tree, l, r, start, end, seg_pos=1): if l > end or r < start: return float('-inf') if l <= start and end <= r: return tree[seg_pos] mid = (start + end) // 2 left_query = query_segment_tree(tree, l, r, start, mid, seg_pos*2) right_query = query_segment_tree(tree, l, r, mid+1, end, seg_pos*2+1) return max(left_query, right_query) # 初始化和输入样例 n = 8 edges = [[0, 1], [0, 2], [1, 3], [1, 4], [2, 5], [2, 6], [6, 7]] weights = {i: i+1 for i in range(n)} # 节点权重 tcd = TreeChainDecomposition(n) for u, v in edges: tcd.add_edge(u, v) tcd.first_dfs() # 第一次 DFS 构建大小和重儿子信息 tcd.second_dfs() # 第二次 DFS 进行链划分 segment_tree = [float('-inf')] * (len(tcd.base_array)*4) # 创建线段 for i in range(len(tcd.base_array)): update_segment_tree(segment_tree, i, weights[tcd.base_array[i]], 0, len(tcd.base_array)-1) # 查询路径最大值函数 def query_path_max(node_u, node_v): result = float('-inf') while tcd.chain_idx[node_u] != tcd.chain_idx[node_v]: if tcd.depth[tcd.chain_idx[node_u]] < tcd.depth[tcd.chain_idx[node_v]]: node_u, node_v = node_v, node_u current_chain_head = tcd.chain_idx[node_u] pos_start = tcd.pos_in_base[current_chain_head] pos_end = tcd.pos_in_base[node_u] result = max(result, query_segment_tree(segment_tree, pos_start, pos_end, 0, len(tcd.base_array)-1)) node_u = tcd.parent[current_chain_head] last_chain_head = tcd.chain_idx[node_u] pos_start = min(tcd.pos_in_base[node_u], tcd.pos_in_base[node_v]) pos_end = max(tcd.pos_in_base[node_u], tcd.pos_in_base[node_v]) result = max(result, query_segment_tree(segment_tree, pos_start, pos_end, 0, len(tcd.base_array)-1)) return result # 测试查询 print(query_path_max(0, 7)) # 输出路径最大值 ``` 上述代码展示了如何结合链剖分和动态规划解决问的过程。其中,动态规划的部分体现在对每个节点的最终权值进行了预先存储,并通过线段支持高效的区间查询[^5]。 --- ### 总结 链剖分提供了强大的工具来简化树形结构的操作,而动态规划能够有效降低复杂度。两者结合后,在许多实际应用中表现出色,尤其是在涉及大量路径查询的情况下。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值