树状DP 笔记

最新推荐文章于 2024-04-06 21:40:24 发布
最新推荐文章于 2024-04-06 21:40:24 发布
阅读量114 收藏
点赞数 1
分类专栏： 左神笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45045689/article/details/108172062
版权

前言

树状DP 要比 在数组上或在矩阵上的 DP 要简单，因为，在树的结构上，总是从子节点推到父节点的。

树状DP 难点是 由可能性得到的返回值类型。

 

在一棵树中，找结点值的最大和最小

可以对树进行一次遍历，在树中找到最大最小值。

我们也可以用树状DP来完成。当前结点的最值 由当前结点的值，和左孩子的最值 和 右孩子的最值决定。

struct Node{
	int value;
	Node *left = NULL;
	Node *right = NULL;
	Node(int data){
		value = data;
	}
};
struct ReturnData
{
	int max, min;
	ReturnData(int Min, int Max){
		min = Min;
		max = Max;
	}
};


ReturnData process(Node *head)
{
	if (head == NULL){
		return ReturnData(INT_MAX, INT_MIN);
	}//if
	ReturnData leftData = process(head->left);
	ReturnData rightData = process(head->right);

	return ReturnData(
		min(min(leftData.min, rightData.min),head->value),
		max(max(leftData.max, rightData.max), head->value));
}

void PrintTree(Node *root, int nLayer)
{
	if (root == NULL){
		return;
	}

	PrintTree(root->right, nLayer + 3);
	for (int i = 0; i < nLayer; i++){
		printf(" ");
	}
	printf("%d\n", root->value);
	PrintTree(root->left, nLayer + 3);
}

void DeteleNode(Node* head)
{
	if (head == NULL){
		return;
	}
	DeteleNode(head->left);
	DeteleNode(head->right);
	delete head;
}

int main()
{
	Node* head = new Node(6);
	head->left = new Node(1);
	head->left->left = new Node(1);
	head->left->right = new Node(3);
	head->right = new Node(12);
	head->right->left = new Node(10);
	head->right->left->left = new Node(4);
	head->right->left->left->left = new Node(2);
	head->right->left->left->right = new Node(5);
	head->right->left->right = new Node(14);
	head->right->left->right->left = new Node(11);
	head->right->left->right->right = new Node(15);
	head->right->right = new Node(13);
	head->right->right->left = new Node(20);
	head->right->right->right = new Node(16);

	PrintTree(head,0);
	ReturnData result = process(head);
	cout << result.max << " " << result.min << endl;

	DeteleNode(head);
	return 0;
}

 

 

在一棵树中，求其中的最大二叉搜索子树

子树的概念：在一个根结点下，下边的后代结点都要有。

拓扑结构：在一个根结点下，下边的后代结点不一定都有。

题解：从小到大找子树是否为二叉搜索子树。在当前结点中，看看结点左孩子的最大二叉搜索子树 , 和结点的右孩子的最大二叉搜索子树，取最大值。如果当前结点左孩子的最大二叉搜索子树的头结点是它本身，当前结点右孩子的最大二叉搜索子树的头结点是它本身，说明可能要产生更大的二叉搜索子树了。

struct Node{
	int value;
	Node *left = NULL;
	Node *right = NULL;
	Node(int data){
		value = data;
	}
};
struct ReturnType
{
	int size;
	Node *head;
	int min, max;
	ReturnType(int a, Node *b, int c, int d){
		size = a;
		head = b;
		min = c;
		max = d;
	}
};
ReturnType process(Node *head)
{
	if (head == NULL){
		return ReturnType(0, NULL, INT_MAX, INT_MIN);
	}
	Node *left = head->left;
	ReturnType leftSubTreeInfo = process(left);
	Node *right = head->right;
	ReturnType rightSubTreeInfo = process(right);

	int includeltSelf = 0;
	if (leftSubTreeInfo.head == left
		&& rightSubTreeInfo.head == right
		&& head->value > leftSubTreeInfo.max
		&& head->value < rightSubTreeInfo.min
		){
		includeltSelf = leftSubTreeInfo.size + rightSubTreeInfo.size + 1;
	}//if

	int p1 = leftSubTreeInfo.size;
	int p2 = rightSubTreeInfo.size;
	int maxSize = max(max(p1, p2), includeltSelf);

	Node* maxHead = p1 > p2 ? leftSubTreeInfo.head : rightSubTreeInfo.head;
	if (maxSize == includeltSelf){
		maxHead = head;
	}//if

	return ReturnType(maxSize, maxHead,
		min(min(leftSubTreeInfo.min, rightSubTreeInfo.min), head->value),
		max(max(leftSubTreeInfo.max, rightSubTreeInfo.max), head->value));
}

void PrintTree(Node *root, int nLayer)
{
	if (root == NULL){
		return;
	}

	PrintTree(root->right, nLayer + 3);
	for (int i = 0; i < nLayer; i++){
		printf(" ");
	}
	printf("%d\n", root->value);
	PrintTree(root->left, nLayer + 3);
}

void DeteleNode(Node* head)
{
	if (head == NULL){
		return;
	}
	DeteleNode(head->left);
	DeteleNode(head->right);
	delete head;
}

int main()
{
	Node* head = new Node(6);
	head->left = new Node(1);
	head->left->left = new Node(0);
	head->left->right = new Node(3);
	head->right = new Node(12);
	head->right->left = new Node(10);
	head->right->left->left = new Node(4);
	head->right->left->left->left = new Node(2);
	head->right->left->left->right = new Node(5);
	head->right->left->right = new Node(14);
	head->right->left->right->left = new Node(11);
	head->right->left->right->right = new Node(15);
	head->right->right = new Node(13);
	head->right->right->left = new Node(20);
	head->right->right->right = new Node(16);

	PrintTree(head, 0);
	ReturnType bst = process(head);
	cout << endl << endl;
	PrintTree(bst.head, 0);

	DeteleNode(head);
	return 0;
}

求一个树上的最远距离

节点A 走到 节点B 的距离为：A 走到 B最短路径上的节点个数。

题解：返回类型为由该节点和该节点的所有子孙节点构成的子树 的 最远距离， 和该结点的高度。

struct Node{
	int value;
	Node *left = NULL;
	Node *right = NULL;
	Node(int data){
		value = data;
	}
};
struct ReturnType
{
	int maxDistance;
	int h;
	ReturnType(int a, int b) :maxDistance(a), h(b){}
};

ReturnType process(Node *head)
{
	if (head == NULL){
		return ReturnType(0,0);
	}//if
	ReturnType leftReturnType = process(head->left);
	ReturnType rightReturnType = process(head->right);
	int includeHeadDistance = leftReturnType.h + rightReturnType.h + 1;
	int p1 = leftReturnType.maxDistance;
	int p2 = rightReturnType.maxDistance;
	int resultDistance = max(max(p1, p2), includeHeadDistance);
	int curHeight = max(leftReturnType.h, rightReturnType.h) + 1;
	
	return ReturnType(resultDistance,curHeight);
}

void PrintTree(Node *root, int nLayer)
{
	if (root == NULL){
		return;
	}

	PrintTree(root->right, nLayer + 3);
	for (int i = 0; i < nLayer; i++){
		printf(" ");
	}
	printf("%d\n", root->value);
	PrintTree(root->left, nLayer + 3);
}

void DeteleNode(Node* head)
{
	if (head == NULL){
		return;
	}
	DeteleNode(head->left);
	DeteleNode(head->right);
	delete head;
}

int main()
{
	Node* head = new Node(6);
	head->left = new Node(1);
	head->left->left = new Node(1);
	head->left->right = new Node(3);
	head->right = new Node(12);
	head->right->left = new Node(10);
	head->right->left->left = new Node(4);
	head->right->left->left->left = new Node(2);
	head->right->left->left->right = new Node(5);
	head->right->left->right = new Node(14);
	head->right->left->right->left = new Node(11);
	head->right->left->right->right = new Node(15);
	head->right->right = new Node(13);
	head->right->right->left = new Node(20);
	head->right->right->right = new Node(16);

	PrintTree(head,0);
	ReturnType result = process(head);
	cout << result.maxDistance << " " << result.h << endl;

	DeteleNode(head);
	return 0;
}

最大高兴度

题目：

公司开party ，有这样一个规定，一个员工来了，那么它的直接上级和直接下级不可以来，每个员工对参加party 都有各自的高兴度。给你一个树状的员工职位表，要你决定谁来，谁不来，并且总高兴度要最大。

题解：

每个节点上有两种可能性，1.该节点来了，以这个节点为根的子树的最大高兴度。

2.该节点没来了，以这个节点为根的子树的最大高兴度。

所以我们的返回数据定义为了

struct ReturnType
{
	int come_MaxHappy;
	int notCome_MaxHappy;
	ReturnType(int a = 0, int b = 0) :come_MaxHappy(a), notCome_MaxHappy(b){}
};

再由这个返回数据 推出 它的祖先节点的返回数据。

 

struct Node{
	int happyFactor;
	vector<Node*> nexts;
	Node(int a){
		happyFactor = a;
	}
};
struct ReturnType
{
	int come_MaxHappy;
	int notCome_MaxHappy;
	ReturnType(int a = 0, int b = 0) :come_MaxHappy(a), notCome_MaxHappy(b){}
};

ReturnType process(Node *head)
{
	int come_MaxHappy = 0;
	int notCome_MaxHappy = 0;
	Node* next = NULL;
	ReturnType nextData;

	for (int i = 0; i < head->nexts.size(); i++){
		next = head->nexts[i];
		nextData = process(next);
		come_MaxHappy += nextData.notCome_MaxHappy;
		notCome_MaxHappy += max(nextData.come_MaxHappy, nextData.notCome_MaxHappy);
	}//for
	return ReturnType(come_MaxHappy,notCome_MaxHappy);
}

 

判断一棵树是否为平衡二叉树

题解：可能性，返回一个树是否是平衡的，以及该树的高度。它的父节点拿到这些信息后，如果它的子树是不平衡的，那么，整棵树一定不平衡。如果它的子树是平衡的， 那么我们用 右子树的高度减去 左子树的高度...

struct Node{
	int value;
	Node *left = NULL;
	Node *right = NULL;
	Node(int a){
		value = a;
	}
};
struct ReturnType
{
	bool isBalance;
	int h;
	ReturnType(bool a, int b){
		isBalance = a;
		h = b;
	}
};

ReturnType process(Node *head)
{
	if (head == NULL){
		return ReturnType(true, 0);
	}
	ReturnType leftData = process(head->left);
	if (leftData.isBalance == false){
		return ReturnType(false, 0);
	}//if

	ReturnType rightData = process(head->right);
	if (rightData.isBalance == false){
		return ReturnType(false, 0);
	}//if
	if (abs(rightData.h - leftData.h) > 1){
		return ReturnType(false, 0);
	}//if
	return ReturnType(true, max(leftData.h, rightData.h) + 1);
}

void PrintTree(Node *root, int nLayer)
{
	if (root == NULL){
		return;
	}

	PrintTree(root->right, nLayer + 3);
	for (int i = 0; i < nLayer; i++){
		printf(" ");
	}
	printf("%d\n", root->value);
	PrintTree(root->left, nLayer + 3);
}

void DeteleNode(Node* head)
{
	if (head == NULL){
		return;
	}
	DeteleNode(head->left);
	DeteleNode(head->right);
	delete head;
}

int main()
{
	Node* head = new Node(6);
	head->left = new Node(1);
	head->left->left = new Node(1);
	head->left->right = new Node(3);
	head->right = new Node(12);
	head->right->left = new Node(10);
	head->right->left->left = new Node(4);
	head->right->left->left->left = new Node(2);
	head->right->left->left->right = new Node(5);
	head->right->left->right = new Node(14);
	head->right->left->right->left = new Node(11);
	head->right->left->right->right = new Node(15);
	head->right->right = new Node(13);
	head->right->right->left = new Node(20);
	head->right->right->right = new Node(16);

	PrintTree(head, 0);
	ReturnType result = process(head);
	cout << endl << endl;
	cout << result.isBalance << endl;

	DeteleNode(head);
	return 0;
}

 

Bil!
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树状dp(含链式前向星）
nowting的博客
04-09 307
算法
树形DP-我的学习笔记
最新发布
05-17
就是赚个积分啊
树形DP入门
热门推荐
深秋的落叶
08-07 1万+
今天开始做老师给的专辑，打开DP专辑 A题 Rebuilding Roads 直接不会了，发现是树形DP，百度了下了该题，看了老半天看不懂 想死的冲动都有了 最后百度了下，树形DP入门，找到了 poj 2342 Anniversary party   题意： 某公司要举
算法：树形dp（树状dp）
m0_63997099的博客
04-06 2215
树状dp的基本概念 和 模板题
树状dp学习笔记
飞向更远的博客
09-01 163
树状dp前言别墅派对[HDU2412]题目描述代码 前言 树状dp顾名思义就是在树形结构上实现的动态规划，动态规划自身是多阶段的决策问题，而树形结构有层次性，正好对应了动态规划的多个阶段。其求解过程一般是自底向上，将子树从小到大作为动规的阶段。一般都是采用dfs，递归求解子树，回溯时从子节点向上进行状态转移，在以当前结点为根的所有子树都求解完毕后，才可以求解当前结点。 这里我直接用相关的题目来加深大家对树状dp的学习。 别墅派对[HDU2412] 题目链接 题目描述 独立集问题，独立集是指在图中两两互不相邻
树状DP
HandsomeHow的博客
07-19 2664
今天我们来学一下树状DP 树状DP 一听就明白，树上的DP，父亲的状态要根据儿子的状态来确定，而树这种东西呢，一般DFS一遍就可以了。 先来两个题吧。 Anniversary party Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 6456   Accepted:
树形DP
飓风之心
12-12 420
DP有些求骗的东西，比如树形DP。 怎么说呢，树也是个DAG，按理说，是DAG就能动规。用题说事 先看一道题 再来一道题 给你三个题 几个知识点待补充 树的最大独立集 树的重心质心 树的直径树的最长路径最远点对 OBST最优排序二叉树 总结一下用题说事先看一道题洛谷P1271 聚会的快乐得自己建树，人名字符串还要映射……板恶心……说正事。 这道题里，上司—下属关系就是一个天然的有向边，利用它，从
树形DP（动态规划）.pptx
01-12
树形DP.pptx
区间DP概率DP树形DP插头DP
09-05
区间DP概率DP树形DP插头DP，每种DP一道典型例题，有助于初学者
树形DP浅略总结
05-13
NOIP 提高2_树形DP
10-30
NOIP 提高2_树形DP
树状dp
shi_zi_183的博客
08-18 1934
树状dp 在树结构上做dp，常见的题型是：给出一棵树，让你实现最小代价或找到最大收益。 树这种结构本身具有“子结构”具有递归性，所以非常适合进行dp。 基于树的解题步骤一般是：先把树转为有根树（如果是几个互不连通的树，就加一个虚拟根，它连接所有孤立的树），然后在树上做DFS，递归到最底层的叶子节点，再一层层返回信息更新至根结点。显然，树上的DP所操作的就是这一层层返回的信息。不同的题目需要灵活设计不同的DP状态和转移方程。 树形dp的基本操作 先看一个简单的入门题。通过这一题，了解树的存储，以及如何在树上设
树状 dp
qq_57862276的博客
03-15 765
树状DP主要母问题： 1.子树的大小 2.树的平衡点（重心） 3树的最大独立集，树的最小覆盖点，树的最小支配集 4.树上背包问题 5.树的直径 子树的大小 例题描述：给定一个大小为n的树，求以i为根的子树大小。 1.设F[i] 为以i为根的子树大小 2.状态转移：F[i]=Σ（1，k）f[k] 代码如下： #include<bits/stdc++.h> using namespace std; int n; int f[1001]; vector<int>e[1001]; void
【DP_树形DP专辑】【9月9最新更新】
07-10 1万+
树，一种十分优美的数据结构，因为它本身就具有的递归性，所以它和子树见能相互传递很多信息，还因为它作为被限制的图在上面可进行的操作更多，所以各种用于不同地方的树都出现了，二叉树、三叉树、静态搜索树、AVL树，线段树、SPLAY树，后缀树等等..      枚举那么多种数据结构只是想说树方面的内容相当多，本专辑只针对在树上的动态规划，即树形DP.做树形DP一般步骤是先将树转换为有根树，然后在树上
树状dp Tree of Tree
你若盛开 清风自来
04-06 624
You're given a tree with weights of each node, you need to find the maximum subtree of specified size of this tree. Tree Definition A tree is a connected graph which contains no cycles.
树状DP1
hollyidyllic的博客
12-04 235
刷DP例题刷到了树状DP…??? 想着deadline要到了，就赶紧刷完了深度搜索作业，然后发现有DP例题做了下，石子归并是环形的（我就记得是环形，tsoj怎么不是T_T），然后看到了P1352 没有上司的舞会好歹写个题解 纪念下今天的追赶deadline 就这一题了！ 这是一个简单的树状DP 先上题目描述 题目描述 某大学有N个职员，编号为1~N。他们之间有从属关系，也就是说他们的关系就像一棵以...
生命之树----树状dp
scwMason的博客
03-02 465
原题: 在X森林里，上帝创建了生命之树。 他给每棵树的每个节点（叶子也称为一个节点）上，都标了一个整数，代表这个点的和谐值。 上帝要在这棵树内选出一个非空节点集S，使得对于S中的任意两个点a,b，都存在一个点列 {a, v1, v2, ..., vk, b} 使得这个点列中的每个点都是S里面的元素，且序列中相邻两个点间有一条边相连。 在这个前提下，上帝要使得S中的点所对应的整数的和尽量大。 这...
python树形dp
04-08
在Python中，可以使用递归或者迭代的方式实现树形DP。 树形DP的基本思想是，从树的叶子节点开始，逐层向上计算每个节点的状态，并利用已经计算过的节点状态来更新当前节点的状态。这样可以通过自底向上的方式，逐步...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值