【深度优先搜索】【树】【图论】2973. 树中每个节点放置的金币数目

作者推荐

视频算法专题

本博文涉及知识点

深度优先搜索 树 图论 分类讨论

LeetCode2973. 树中每个节点放置的金币数目

给你一棵 n 个节点的 无向 树，节点编号为 0 到 n - 1 ，树的根节点在节点 0 处。同时给你一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间有一条边。
给你一个长度为 n 下标从 0 开始的整数数组 cost ，其中 cost[i] 是第 i 个节点的 开销 。
你需要在树中每个节点都放置金币，在节点 i 处的金币数目计算方法如下：
如果节点 i 对应的子树中的节点数目小于 3 ，那么放 1 个金币。
否则，计算节点 i 对应的子树内 3 个不同节点的开销乘积的 最大值 ，并在节点 i 处放置对应数目的金币。如果最大乘积是 负数 ，那么放置 0 个金币。
请你返回一个长度为 n 的数组 coin ，coin[i]是节点 i 处的金币数目。
示例 1：
在这里插入图片描述

输入：edges = [[0,1],[0,2],[0,3],[0,4],[0,5]], cost = [1,2,3,4,5,6]
输出：[120,1,1,1,1,1]
解释：在节点 0 处放置 6 * 5 * 4 = 120 个金币。所有其他节点都是叶子节点，子树中只有 1 个节点，所以其他每个节点都放 1 个金币。
示例 2：
在这里插入图片描述

输入：edges = [[0,1],[0,2],[1,3],[1,4],[1,5],[2,6],[2,7],[2,8]], cost = [1,4,2,3,5,7,8,-4,2]
输出：[280,140,32,1,1,1,1,1,1]
解释：每个节点放置的金币数分别为：

  • 节点 0 处放置 8 * 7 * 5 = 280 个金币。
  • 节点 1 处放置 7 * 5 * 4 = 140 个金币。
  • 节点 2 处放置 8 * 2 * 2 = 32 个金币。
  • 其他节点都是叶子节点，子树内节点数目为 1 ，所以其他每个节点都放 1 个金币。
    示例 3：
    在这里插入图片描述

输入：edges = [[0,1],[0,2]], cost = [1,2,-2]
输出：[0,1,1]
解释：节点 1 和 2 都是叶子节点，子树内节点数目为 1 ，各放置 1 个金币。节点 0 处唯一的开销乘积是 2 * 1 * -2 = -4 。所以在节点 0 处放置 0 个金币。

提示：
2 <= n <= 2 * 104
edges.length == n - 1
edges[i].length == 2
0 <= ai, bi < n
cost.length == n
1 <= |cost[i]| <= 104
edges 一定是一棵合法的树。

分类讨论

情况表面上很多，时间上只有4情况：
{ 1 不足 3 个节点 最大的三个正数的乘积 至少 3 个正数节点 1 个正数和 2 个负数的乘积 至少一个正数节点， 2 个负数节点 0 o t h e r \begin{cases} 1 &不足3个节点 \\ 最大的三个正数的乘积 & 至少3个正数节点\\ 1个正数和2个负数的乘积 & 至少一个正数节点，2个负数节点\\ 0 & other \\ \end{cases} ⎩ ⎨ ⎧​1最大的三个正数的乘积1个正数和2个负数的乘积0​不足3个节点至少3个正数节点至少一个正数节点，2个负数节点other​
正数节点都只需要记录3个节点，2个不够。

3个负数节点，0个正数节点。值是0。
2个负数节点，0个正数节点。值是1。
注意：cost[i]不会为0。

代码

核心代码

class CNeiBo2
{
public:CNeiBo2(int n, bool bDirect, int iBase = 0) :m_iN(n), m_bDirect(bDirect), m_iBase(iBase){m_vNeiB.resize(n);}CNeiBo2(int n, vector<vector<int>>& edges, bool bDirect, int iBase = 0) :m_iN(n), m_bDirect(bDirect), m_iBase(iBase){m_vNeiB.resize(n);for (const auto& v : edges){m_vNeiB[v[0] - iBase].emplace_back(v[1] - iBase);if (!bDirect){m_vNeiB[v[1] - iBase].emplace_back(v[0] - iBase);}}}inline void Add(int iNode1, int iNode2){iNode1 -= m_iBase;iNode2 -= m_iBase;m_vNeiB[iNode1].emplace_back(iNode2);if (!m_bDirect){m_vNeiB[iNode2].emplace_back(iNode1);}}const int m_iN;const bool m_bDirect;const int m_iBase;vector<vector<int>> m_vNeiB;
};class Solution {
public:vector<long long> placedCoins(vector<vector<int>>& edges, vector<int>& cost) {m_vAns.resize(cost.size());m_cost = cost;CNeiBo2 neiBo(cost.size(), edges, false);std::priority_queue<int> maxHeap;std::priority_queue<int, vector<int>, greater<int> > minHeap;DFS(maxHeap, minHeap, neiBo.m_vNeiB, 0, -1);return m_vAns;}void DFS(std::priority_queue<int>& maxHeap, std::priority_queue<int, vector<int>, greater<int> >& minHeap,const vector<vector<int>>& neiBo, int cur, int par){if (m_cost[cur] >= 0){minHeap.emplace(m_cost[cur]);}else{maxHeap.emplace(m_cost[cur]);}for (const auto& next : neiBo[cur]){if (next == par){continue;}std::priority_queue<int> maxHeap1;std::priority_queue<int, vector<int>, greater<int> > minHeap1;DFS(maxHeap1,minHeap1,neiBo, next, cur);Union(maxHeap, maxHeap1);Union(minHeap, minHeap1);}auto Cal = [&](){if (maxHeap.size() + minHeap.size() <3 ){return 1LL;} long long llRet = 0;auto v1 = ToVector(minHeap);auto v2 = ToVector(maxHeap);			if (3 == minHeap.size()){		llRet =max(llRet, (long long)v1[0] * v1[1] * v1[2]);}if (minHeap.size()&& (maxHeap.size() >= 2)){				if (v2.size() > 2){v2.erase(v2.begin());}				llRet = max(llRet, (long long)v1.back() * v2[0] * v2[1]);}return llRet;};m_vAns[cur] = Cal();}protected:template<class T>vector<int> ToVector(T heap){vector<int> v;while (heap.size()){v.emplace_back(heap.top());heap.pop();}T heap2(v.begin(), v.end());heap2.swap(heap);return v;}template<class T>void Union(T& heap1, T& heap2){while (heap2.size()){heap1.emplace(heap2.top());heap2.pop();}while (heap1.size() > 3){heap1.pop();}}vector<long long> m_vAns;vector<int> m_cost;
};

测试用例

template<class T,class T2>
void Assert(const T& t1, const T2& t2)
{assert(t1 == t2);
}template<class T>
void Assert(const vector<T>& v1, const vector<T>& v2)
{if (v1.size() != v2.size()){assert(false);return;}for (int i = 0; i < v1.size(); i++){Assert(v1[i], v2[i]);}}int main()
{vector<vector<int>> edges;vector<int> cost;{Solution sln;edges = { {0,1},{0,2},{2,3} }, cost = { 10000, -10000, 10000, -10000 };auto res = sln.placedCoins(edges, cost);Assert({ 1000000000000,1,1,1 }, res);}{Solution sln;edges = { {0,1},{0,2},{0,3},{0,4},{0,5} }, cost = { 1,2,3,4,5,6 };auto res = sln.placedCoins(edges, cost);Assert({ 120,1,1,1,1,1 }, res);}{Solution sln;edges = { {0,1},{0,2},{1,3},{1,4},{1,5},{2,6},{2,7},{2,8} }, cost = { 1,4,2,3,5,7,8,-4,2 };auto res = sln.placedCoins(edges, cost);Assert({ 280,140,32,1,1,1,1,1,1 }, res);}{Solution sln;edges = { {0,1},{0,2} }, cost = { 1,2,-2 };auto res = sln.placedCoins(edges, cost);Assert({ 0,1,1 }, res);}{Solution sln;edges = { {0,1},{0,2},{0,3},{0,4},{0,5},{0,6},{0,7},{0,8},{0,9},{0,10},{0,11},{0,12},{0,13},{0,14},{0,15},{0,16},{0,17},{0,18},{0,19},{0,20},{0,21},{0,22},{0,23},{0,24},{0,25},{0,26},{0,27},{0,28},{0,29},{0,30},{0,31},{0,32},{0,33},{0,34},{0,35},{0,36},{0,37},{0,38},{0,39},{0,40},{0,41},{0,42},{0,43},{0,44},{0,45},{0,46},{0,47},{0,48},{0,49},{0,50},{0,51},{0,52},{0,53},{0,54},{0,55},{0,56},{0,57},{0,58},{0,59},{0,60},{0,61},{0,62},{0,63},{0,64},{0,65},{0,66},{0,67},{0,68},{0,69},{0,70},{0,71},{0,72},{0,73},{0,74},{0,75},{0,76},{0,77},{0,78},{0,79},{0,80},{0,81},{0,82},{0,83},{0,84},{0,85},{0,86},{0,87},{0,88},{0,89},{0,90},{0,91},{0,92},{0,93},{0,94},{0,95},{0,96},{0,97},{0,98},{0,99} };cost={-5959, 602, -6457, 7055, -1462, 6347, 7226, -8422, -6088, 2997, -7909, 6433, 5217, 3294, -3792, 7463, 8538, -3811, 5009, 151, 5659, 4458, -1702, -1877, 2799, 9861, -9668, -1765, 2181, -8128, 7046, 9529, 6202, -8026, 6464, 1345, 121, 1922, 7274, -1227, -9914, 3025, 1046, -9368, -7368, 6205, -6342, 8091, -6732, -7620, 3276, 5136, 6871, 4823, -1885, -4005, -3974, -2725, -3845, -8508, 7201, -9566, -7236, -3386, 4021, 6793, -8759, 5066, 5879, -5171, 1011, 1242, 8536, -8405, -9646, -214, 2251, -9934, -8820, 6206, 1006, 1318, -9712, 7230, 5608, -4601, 9185, 346, 3056, 8913, -2454, -3445, -4295, 4802, -8852, -6121, -4538, -5580, -9246, -6462};auto res = sln.placedCoins(edges, cost);sort(cost.begin(), cost.end());Assert({ 971167251036, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, res);}
}

第二版

class CNeiBo2
{
public:
CNeiBo2(int n, bool bDirect, int iBase = 0) :m_iN(n), m_bDirect(bDirect), m_iBase(iBase)
{
m_vNeiB.resize(n);
}
CNeiBo2(int n, vector<vector>& edges, bool bDirect, int iBase = 0) :m_iN(n), m_bDirect(bDirect), m_iBase(iBase)
{
m_vNeiB.resize(n);
for (const auto& v : edges)
{
m_vNeiB[v[0] - iBase].emplace_back(v[1] - iBase);
if (!bDirect)
{
m_vNeiB[v[1] - iBase].emplace_back(v[0] - iBase);
}
}
}
inline void Add(int iNode1, int iNode2)
{
iNode1 -= m_iBase;
iNode2 -= m_iBase;
m_vNeiB[iNode1].emplace_back(iNode2);
if (!m_bDirect)
{
m_vNeiB[iNode2].emplace_back(iNode1);
}
}
const int m_iN;
const bool m_bDirect;
const int m_iBase;
vector<vector> m_vNeiB;
};

class Solution {
public:
vector placedCoins(vector<vector>& edges, vector& cost) {
m_cost = cost;
m_vAns.resize(cost.size());
CNeiBo2 neiBo(cost.size(), edges, false);
multiset<int, greater> more0;
multiset less0;
DFS(more0, less0, neiBo.m_vNeiB, 0, -1);
return m_vAns;
}
void DFS(multiset<int, greater>& more0, multiset& less0, vector<vector>& neiBo, int cur, int par)
{
if (m_cost[cur] > 0)
{
more0.emplace(m_cost[cur]);
}
else
{
less0.emplace(m_cost[cur]);
}
for (const auto& next : neiBo[cur])
{
if (next == par)
{
continue;
}
multiset<int, greater> more01;
multiset less01;
DFS(more01, less01, neiBo, next, cur);
Union(more0, more01);
Union(less0, less01);
}
long long& llRet = m_vAns[cur];
if (more0.size() + less0.size() < 3)
{
llRet = 1;
return;
}
if (more0.size() >= 3)
{
auto it = more0.begin();
llRet = max(llRet, (long long)*(it++) * *(it++) * (it++));
}
if (more0.size() && (less0.size() >= 2))
{
llRet = max(llRet, (long long)(more0.begin()) * *(less0.begin()) * *(std::next(less0.begin())));
}
};
template
void Union(T& set1, const T& set2)
{
for (const auto& n : set2)
{
set1.emplace(n);
}
while (set1.size() > 3)
{
set1.erase(prev(set1.end()));
}
}
vector m_cost;
vector m_vAns;
};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快

速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关

下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 C++17
如无特殊说明，本算法用**C++**实现。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/465269.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【leetcode热题100】反转链表 II

【leetcode热题100】反转链表 II

给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], left 2, right 4 输出&#xff1a;[1,4,3,2…
阅读更多...
Java 学习和实践笔记（6）

Java 学习和实践笔记（6）

各数据类型所占的空间&#xff1a; byte: 1个字节 short&#xff1a;2个字节 int&#xff1a;4个 long&#xff1a;8个 float&#xff1a;4个 double: 8个 char:1个 boolean:1bit 所有引用数据类型都是4个字节&#xff0c;实际其值是指向该数据类型的地址。 上图中稍特…
阅读更多...
《统计学简易速速上手小册》第9章：统计学在现代科技中的应用（2024 最新版）

《统计学简易速速上手小册》第9章：统计学在现代科技中的应用（2024 最新版）

文章目录 9.1 统计学与大数据9.1.1 基础知识9.1.2 主要案例&#xff1a;社交媒体情感分析9.1.3 拓展案例 1&#xff1a;电商销售预测9.1.4 拓展案例 2&#xff1a;实时交通流量分析 9.2 统计学在机器学习和人工智能中的应用9.2.1 基础知识9.2.2 主要案例&#xff1a;预测客户流…
阅读更多...
浅谈人工智能之深度学习~

浅谈人工智能之深度学习~

目录 前言&#xff1a;深度学习的进展 一&#xff1a;深度学习的基本原理和算法 二&#xff1a;深度学习的应用实例 三&#xff1a;深度学习的挑战和未来发展方向 四&#xff1a;深度学习与机器学习的关系 五&#xff1a;深度学习与人类的智能交互 悟已往之不谏&#xff0…
阅读更多...
操作系统——内存管理(附带Leetcode算法题LRU)

操作系统——内存管理(附带Leetcode算法题LRU)

1.内存管理主要用来干什么&#xff1f; 操作系统的内存管理主要负责内存的分配与回收、内存扩充(虚拟技术)、地址转换(逻辑-物理)、内存保护(保证各进程在自己的内存空间运行&#xff0c;不会越界访问)..... 2.什么是内存碎片&#xff1f; 内存碎片是内存的申请和释放产生的…
阅读更多...
【Linux】进程基础铺垫（一）硬件基础：冯诺依曼体结构

【Linux】进程基础铺垫（一）硬件基础：冯诺依曼体结构

冯诺依曼体结构 一、体系结构&#xff08;硬件上&#xff09;—— 冯诺依曼体系结构二、内存 的引入&#xff1a;为什么在体系结构中要存在内存? ?前言&#xff1a;内存背景 三、在体系结构中 存在内存的原因 以及 内存的意义 一、体系结构&#xff08;硬件上&#xff09;——…
阅读更多...
【大厂AI课学习笔记】【1.6 人工智能基础知识】（2）机器学习

【大厂AI课学习笔记】【1.6 人工智能基础知识】（2）机器学习

目录 必须理解的知识点&#xff1a; 举一个草莓的例子&#xff1a; 机器学习的三个类别&#xff1a; 监督学习&#xff1a; 无监督学习&#xff1a; 强化学习&#xff1a; 更多知识背景&#xff1a; 机器学习的诞生需求 监督学习的关键技术与实现步骤 无监督学习的关…
阅读更多...
winprop二次开发

winprop二次开发

winprop二次开发 前言工具1——整合多个天线结果用途代码实现 未完待续 前言 工作需求&#xff0c;对该软件进行简单地二次开发&#xff0c;都是一些挺简单的代码&#xff0c;单纯是为了上传之后将其从本地删除 工具1——整合多个天线结果 用途 winprop最终的计算结果&…
阅读更多...
机器学习之局部最优和全局最优

机器学习之局部最优和全局最优

(1)局部最优&#xff0c;就是在函数值空间的一个有限区域内寻找最小值;而全局最优&#xff0c;是在函数值空间整个区域寻找最小值问题。 (2)函数局部最小点是它的函数值小于或等于附近点的点&#xff0c;但是有可能大于较远距离的点。 (3)全局最小点是那种它的函数值小于或等于…
阅读更多...
家用小型洗地机好用吗？家用洗地机品牌

家用小型洗地机好用吗？家用洗地机品牌

传统的清洁地面方式&#xff0c;不仅耗费时间、精力&#xff0c;还会造成人的腰酸背痛&#xff0c;带来一连串的家务后遗症&#xff0c;简直是苦不堪言。像洗地机、扫地机器人、吸尘器等电动清洁工具的诞生让人们的清洁更加轻松省事&#xff0c;也凭借着这些优势深受大众喜爱。…
阅读更多...
第78讲 修改密码

第78讲 修改密码

系统管理实现 修改密码实现 前端 modifyPassword.vue&#xff1a; <template><el-card><el-formref"formRef":model"form":rules"rules"label-width"150px"><el-form-item label"用户名&#xff1a;&quo…
阅读更多...
四.Linux实用操作 12-14.环境变量文件的上传和下载压缩和解压

四.Linux实用操作 12-14.环境变量文件的上传和下载压缩和解压

目录 四.Linux实用操作 12.环境变量 环境变量 环境变量--PATH $ 符号 自行设置环境变量 自定义环境变量PATH 总结 四.Linux实用操作 13.文件的上传和下载 上传&#xff0c;下载 rz&#xff0c;sz命令 四.Linux实用操作 14.压缩和解压 压缩格式 tar命令 tar命令压缩…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023