【深度优先搜索】【图论】【树】2646. 最小化旅行的价格总和

news2025/6/24 21:36:09

作者推荐

【数位dp】【动态规划】【状态压缩】【推荐】1012. 至少有 1 位重复的数字

涉及知识点

深度优先搜索 图论 树

LeetCode2646. 最小化旅行的价格总和

现有一棵无向、无根的树，树中有 n 个节点，按从 0 到 n - 1 编号。给你一个整数 n 和一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间存在一条边。
每个节点都关联一个价格。给你一个整数数组 price ，其中 price[i] 是第 i 个节点的价格。
给定路径的 价格总和 是该路径上所有节点的价格之和。
另给你一个二维整数数组 trips ，其中 trips[i] = [starti, endi] 表示您从节点 starti 开始第 i 次旅行，并通过任何你喜欢的路径前往节点 endi 。
在执行第一次旅行之前，你可以选择一些 非相邻节点 并将价格减半。
返回执行所有旅行的最小价格总和。
示例 1：
输入：n = 4, edges = [[0,1],[1,2],[1,3]], price = [2,2,10,6], trips = [[0,3],[2,1],[2,3]]
输出：23
解释：
上图表示将节点 2 视为根之后的树结构。第一个图表示初始树，第二个图表示选择节点 0 、2 和 3 并使其价格减半后的树。
第 1 次旅行，选择路径 [0,1,3] 。路径的价格总和为 1 + 2 + 3 = 6 。
第 2 次旅行，选择路径 [2,1] 。路径的价格总和为 2 + 5 = 7 。
第 3 次旅行，选择路径 [2,1,3] 。路径的价格总和为 5 + 2 + 3 = 10 。
所有旅行的价格总和为 6 + 7 + 10 = 23 。可以证明，23 是可以实现的最小答案。
示例 2：
输入：n = 2, edges = [[0,1]], price = [2,2], trips = [[0,0]]
输出：1
解释：
上图表示将节点 0 视为根之后的树结构。第一个图表示初始树，第二个图表示选择节点 0 并使其价格减半后的树。
第 1 次旅行，选择路径 [0] 。路径的价格总和为 1 。
所有旅行的价格总和为 1 。可以证明，1 是可以实现的最小答案。
提示：
1 <= n <= 50
edges.length == n - 1
0 <= ai, bi <= n - 1
edges 表示一棵有效的树
price.length == n
price[i] 是一个偶数
1 <= price[i] <= 1000
1 <= trips.length <= 100
0 <= starti, endi <= n - 1

两次深度优先搜索

深度优先搜索计算进过各节点多少次

以任何一个节点（比如：0）为整课树的节点，有如下性质：
性质一：路径一定是：起点 → \rightarrow → 公共祖先 → \rightarrow → 终点 特例是：起点或终点就是公共祖先。
性质二：如果某棵子树包括某次旅行的起点或终点，则此次旅行必定经过此子树根节点。如果起点和终点都是此子树的节点，也算。 之后就不算了。
如何判断 节点是否属于子树：
DFS 的开始，给节点编号（访问编号）m_vTime[cur]，从1到大。没有访问就是默认值0。
DFS结束时，访问编号大于等于m_vTime[cur]，是本子树的节点。
m_vNeedVis 记录各节点访问的需要访问的次数。
m_vHasDo 记录那些旅行的公共祖先已经访问。

深度优先搜索枚举半价

{ 子节点节点全价 根节点半价 m i n ( 子节点节点全价，子节点节点半价 ) 根节点全价 \begin{cases} 子节点节点全价 & 根节点半价 \\ min(子节点节点全价，子节点节点半价) & 根节点全价 \\ \end{cases} {子节点节点全价min(子节点节点全价，子节点节点半价)​根节点半价根节点全价​
DFS2返回值两个：
一，全价、半价的较小值。
二，全价的最小值。

代码

核心代码

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:
	int minimumTotalPrice(int n, vector<vector<int>>& edges, vector<int>& price, vector<vector<int>>& trips) {
		CNeiBo2 neiBo(n, edges, false);
		m_vNeedVis.resize(n);
		m_vHasDo.resize(trips.size());
		m_vTime.resize(n);
		m_trips = trips;
		m_price = price;
		DFS(neiBo.m_vNeiB, 0, -1);
		return DFS2(neiBo.m_vNeiB, 0, -1).first;
	}
	void DFS(vector<vector<int>>& neiBo, int cur, int par)
	{
		m_vTime[cur] = ++m_llTime;
		for (const auto& next : neiBo[cur])
		{
			if (next == par)
			{
				continue;
			}
			DFS(neiBo, next, cur);
		}
		for (int i = m_trips.size()-1 ; i >=0 ; i--)
		{
			if (m_vHasDo[i])
			{
				continue;
			}
			const auto& v = m_trips[i];
			if ((m_vTime[v[0]] >= m_vTime[cur]) || (m_vTime[v[1]] >= m_vTime[cur]))
			{
				m_vNeedVis[cur]++;
				if ((m_vTime[v[0]] >= m_vTime[cur]) && (m_vTime[v[1]] >= m_vTime[cur]))
				{ 
					m_vHasDo[i] = true;
				}
			}
		}
	}
	pair<int,int> DFS2(vector<vector<int>>& neiBo, int cur, int par)
	{
		int  i2 = m_price[cur]*m_vNeedVis[cur],i1 =i2/2;
		for (const auto& next : neiBo[cur])
		{
			if (next == par)
			{
				continue;
			}
			auto [i11,i21] = DFS2(neiBo, next, cur);
			i1 += i21;
			i2 += i11;
		}
		return make_pair(min(i1, i2), i2);
	}
	vector<int> m_vNeedVis,m_vTime;// 记录各节点访问的需要访问的次数。
	vector<bool>	m_vHasDo;// 记录那些旅行的公共祖先已经访问。
	int m_llTime = 0;
	vector<vector<int>> m_trips;
	vector<int> m_price;
};

测试用例


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()
{	
	int n;
	vector<int>  price;
	vector<vector<int>> edges, trips;
	{
		Solution sln;
		n = 4, edges = { {0,1},{1,2},{1,3} }, price = { 2,2,10,6 }, trips = { {0,3},{2,1},{2,3} };
		auto res = sln.minimumTotalPrice(n, edges, price, trips);
		Assert(res,23);
	}

	{
		Solution sln;
		n = 2, edges = { {0,1} }, price = { 2,2 }, trips = { {0,0} };
		auto res = sln.minimumTotalPrice(n, edges, price, trips);
		Assert(res, 1);
	}
	{
		Solution sln;
		n = 5, edges = { {1,2},{2,0},{0,3},{3,4} }, price = { 12,26,22,12,2 };
		trips = { {3,3},{3,2},{3,0},{3,4},{1,1},{2,2},{4,0},{0,2},{2,3},{2,1},{4,2},{0,1},{4,2},{0,4},{0,3},{4,0},{4,0},{3,3},{4,3},{2,2},{4,2},{1,4},{3,2},{4,4},{4,2},{2,3},{4,3},{4,4},{4,2},{0,4},{4,2},{3,4},{4,0},{3,2},{3,1},{2,0},{0,4},{3,4},{2,0},{1,4},{4,2},{4,4},{2,1},{0,1},{4,1},{3,4},{0,4},{2,0},{2,0},{3,3},{4,4},{0,1},{0,1},{0,1},{2,0},{0,1},{3,1},{3,4},{3,4},{4,2},{0,4},{4,4},{3,2},{2,1},{3,2},{1,4},{1,0},{4,2},{4,3},{3,1},{4,4},{3,1},{1,0},{0,0},{0,0},{3,0},{0,2},{2,2},{3,3},{0,3} };;
		auto res = sln.minimumTotalPrice(n, edges, price, trips);
		Assert(res, 2037);
	}
	
}

2023年3月

class CNeiBo2
{
public:
CNeiBo2(int n, vector<vector>& edges, bool bDirect)
{
m_vNeiB.resize(n);
for (const auto& v : edges)
{
m_vNeiB[v[0]].emplace_back(v[1]);
if (!bDirect)
{
m_vNeiB[v[1]].emplace_back(v[0]);
}
}
}
vector<vector> m_vNeiB;
};
class Solution {
public:
int minimumTotalPrice(int n, vector<vector>& edges, vector& price, vector<vector>& trips) {
m_vParent.resize(n);
CNeiBo2 neBo(n, edges, false);
dfs(0, -1, neBo.m_vNeiB);
vector vTotalPrice(n);
for (const vector& trip : trips)
{
const auto& v0 = m_vParent[trip[0]];
const auto& v1 = m_vParent[trip[1]];
int i = 0;
for (; (i < min(v0.size(), v1.size())) && (v0[i] == v1[i]); i++);
vTotalPrice[v0[i - 1]] += price[v0[i - 1]];
for (int j = i; j < v0.size(); j++)
{
vTotalPrice[v0[j]] += price[v0[j]];
}
for (int j = i; j < v1.size(); j++)
{
vTotalPrice[v1[j]] += price[v1[j]];
}
}
int iRet = std::accumulate(vTotalPrice.begin(), vTotalPrice.end(), 0);
return iRet - MaxDFS(0, -1, neBo.m_vNeiB, vTotalPrice, true);
}
void dfs(int iCur, int iParent, const vector<vector>& vNeiBo)
{
if (-1 != iParent)
{
m_vParent[iCur] = m_vParent[iParent];
}
m_vParent[iCur].emplace_back(iCur);
for (const auto& next : vNeiBo[iCur])
{
if (iParent == next)
{
continue;
}
dfs(next, iCur, vNeiBo);
}
}
int MaxDFS(int iCur, int iParent, const vector<vector>& vNeiBo, const vector& vTotalPrice,bool bCanRoot)
{
int iRet = 0;
for (const auto& next : vNeiBo[iCur])
{
if (iParent == next)
{
continue;
}
iRet += MaxDFS(next, iCur, vNeiBo, vTotalPrice,true);
}
if ((!bCanRoot) || (0 == vTotalPrice[iCur]))
{
return iRet;
}
int iRet2 = vTotalPrice[iCur] / 2;
for (const auto& next : vNeiBo[iCur])
{
if (iParent == next)
{
continue;
}
iRet2 += MaxDFS(next, iCur, vNeiBo, vTotalPrice, false);
}
return max(iRet, iRet2);
}
vector<vector> m_vParent;
};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步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.coloradmin.cn/o/1453935.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

实例观察 c 语言中 volatile 的作用

实例观察 c 语言中 volatile 的作用

volatile 意思是易变的。 在 c 语言中&#xff0c;如果变量被 volatile 修饰&#xff0c;就是告诉编译器这个变量随时都可能发生变化&#xff0c;那么每次读取变量的时候都会到内存中读取。 如果变量没有被 volatile 修饰&#xff0c;并且编译器发现在多次读取变量之间&#…
阅读更多...
一文搞懂设计模式—观察者模式

一文搞懂设计模式—观察者模式

本文已收录至Github&#xff0c;推荐阅读 &#x1f449; Java随想录 微信公众号&#xff1a;Java随想录 文章目录 使用场景实现方式Java对观察者模式的支持Guava对观察者模式的支持Spring对观察者模式的支持 优缺点 观察者模式&#xff08;Observer Pattern&#xff09;是一种…
阅读更多...
FlashMeeting(基于FFmpeg+openCV)视频语音通讯系统

FlashMeeting(基于FFmpeg+openCV)视频语音通讯系统

Web端体验地址&#xff1a;https://download.csdn.net/download/XiBuQiuChong/88805337 客户端下载地址&#xff1a;https://download.csdn.net/download/XiBuQiuChong/88805337 FlashMeeting(基于FFmpegopenCV)是一整套先进的以FFmpegopenCV技术为基础的视频语音通讯系统。利…
阅读更多...
linux基础IO【文件操作】

linux基础IO【文件操作】

目录 前言&#xff1a; 1.文件理解 2.C语言文件操作 2.1文件打开 2.2文件关闭 2.3文件写入 2.4文件读取 3.系统文件操作 3.1open 3.2close 3.3write 3.4read 4.访问文件本质 前言&#xff1a; 我们在学习文件操作之前先要了解文件的构成&#xff0c;文件 内容 属…
阅读更多...
职业性格在求职应聘和跳槽中的作用

职业性格在求职应聘和跳槽中的作用

性格测试对跳槽者的影响大不大&#xff1f;首先我们要弄清楚两个问题&#xff0c;性格对我们的职业生涯又没有影响&#xff0c;性格测试是什么&#xff0c;职场中有哪些应用&#xff1f;性格可以说从生下来就有了&#xff0c;随着我们的成长&#xff0c;我们的性格也越来越根深…
阅读更多...
Stable Diffusion教程——常用插件安装与测试（一）

Stable Diffusion教程——常用插件安装与测试（一）

前言 随着Stable Diffusion不断演进&#xff0c;越来越多的开发者开始涉足插件开发。尽管网络上存在大量教程&#xff0c;但它们通常零散分布&#xff0c;逐个学习和查找非常耗时&#xff0c;使人感觉每天都在劳累思考。这里总结了Stable Diffusion常用的插件安装与测试方法。…
阅读更多...
【JavaScript】点击选中和取消

【JavaScript】点击选中和取消

效果图 &#xff08;1&#xff09;选中 &#xff08;2&#xff09;取消选中 实现 <template><div class"qualitityIssues"><div style"display: flex;"><div class"course-area"><div :class"checkoutIndex …
阅读更多...
element table 点击按钮 表格滚动条移动

element table 点击按钮 表格滚动条移动

需求场景&#xff1a;表格列数很多的情况下&#xff0c;不想拖拽滚动条查看明细&#xff0c;所以点击按钮直接跳转到对应的位置 代码实现&#xff1a; <template><div><div class "mytable"><el-tableid "testTable"ref "t…
阅读更多...
Qt之条件变量QWaitCondition详解(从使用到原理分析全)

Qt之条件变量QWaitCondition详解(从使用到原理分析全)

QWaitCondition内部实现结构图&#xff1a; 相关系列文章 C之Pimpl惯用法 目录 1.简介 2.示例 2.1.全局配置 2.2.生产者Producer 2.3.消费者Consumer 2.4.测试例子 3.原理分析 3.1.源码介绍 3.2.辅助函数CreateEvent 3.3.辅助函数WaitForSingleObject 3.4.QWaitCo…
阅读更多...
计算机网络之网络安全

计算机网络之网络安全

文章目录 1. 网络安全概述1.1 安全威胁1.1.1 被动攻击1.1.2 主动攻击 1.2 安全服务 2. 密码学与保密性2.1 密码学相关基本概念2.2 对称密钥密码体制2.2.1 DES的加密方法2.2.2.三重DES 2.3 公钥密码体制 3. 报文完整性与鉴别3.1 报文摘要和报文鉴别码3.1.1 报文摘要和报文鉴别码…
阅读更多...
基于微信小程序的健身房私教预约系统，附源码

基于微信小程序的健身房私教预约系统，附源码

博主介绍&#xff1a;✌程序员徐师兄、7年大厂程序员经历。全网粉丝12w、csdn博客专家、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精彩专栏推荐订阅&#x1f447;…
阅读更多...
模型可视化

模型可视化

模型标题可视化 可视化工具&#xff1a;Graphiz、Netron、ZetaneEngine 7.2.2Graphiz可视化工具 Graphiz是一个由AT&T实验室启动的开源工具包&#xff0c;用于绘制DOT语言脚本描述的图形&#xff0c;使用它可以非常方便地对任何图形进行可视化。 Graphiz的使用步骤包括创…
阅读更多...
【ChatIE】论文解读：Zero-Shot Information Extraction via Chatting with ChatGPT

【ChatIE】论文解读：Zero-Shot Information Extraction via Chatting with ChatGPT

文章目录 介绍ChatIEEntity-Relation Triple Extration (RE)Named Entity Recognition (NER)Event Extraction (EE) 实验结果结论 论文&#xff1a;Zero-Shot Information Extraction via Chatting with ChatGPT 作者&#xff1a;Xiang Wei, Xingyu Cui, Ning Cheng, Xiaobin W…
阅读更多...
PyTorch使用Tricks：学习率衰减 ！！

PyTorch使用Tricks：学习率衰减 ！！

文章目录 前言 1、指数衰减 2、固定步长衰减 3、多步长衰减 4、余弦退火衰减 5、自适应学习率衰减 6、自定义函数实现学习率调整&#xff1a;不同层不同的学习率 前言 在训练神经网络时&#xff0c;如果学习率过大&#xff0c;优化算法可能会在最优解附近震荡而无法收敛&#x…
阅读更多...
算法刷题:长度最小的子数组

算法刷题:长度最小的子数组

长度最小的子数组 .题目链接题目详情算法原理滑动窗口定义指针进窗口判断出窗口 我的答案 . 题目链接 长度最小的子数组 题目详情 算法原理 滑动窗口 这道题,我们采用滑动窗口的思想来解决,具体步骤如图所示 定义指针 如图所示,两个指针都需要从左往右进行遍历,因此初始值…
阅读更多...
AIGC实战——能量模型(Energy-Based Model)

AIGC实战——能量模型(Energy-Based Model)

AIGC实战——能量模型 0. 前言1. 能量模型1.1 模型原理1.2 MNIST 数据集1.3 能量函数 2. 使用 Langevin 动力学进行采样2.1 随机梯度 Langevin 动力学2.2 实现 Langevin 采样函数 3. 利用对比散度训练小结系列链接 0. 前言 能量模型 (Energy-based Model, EBM) 是一类常见的生…
阅读更多...
食物厨艺展示404错误页面模板源码

食物厨艺展示404错误页面模板源码

食物厨艺展示404错误页面模板源码&#xff0c;HTMLCSSJSCSS,记事本打开源码文件可以进行内容文字之类的修改&#xff0c;双击html文件可以本地运行效果&#xff0c;也可以上传到服务器里面&#xff0c;重定向这个界面 蓝奏云&#xff1a;https://wfr.lanzout.com/i3uC71oj52ah…
阅读更多...
初识数据库：探索数据的世界

初识数据库：探索数据的世界

初识数据库&#xff1a;探索数据的世界 1. 什么是数据库&#xff1f;2. 数据库的类型2.1 关系型数据库&#xff08;RDBMS&#xff09;2.2 非关系型数据库&#xff08;NoSQL&#xff09; 3. 为什么使用数据库&#xff1f;4. 如何选择合适的数据库&#xff1f;5. 结语 在信息技术…
阅读更多...
ovs和ovn安装

ovs和ovn安装

ovn和ovs介绍 ovn架构图 CMS||-----------|-----------| | || OVN/CMS Plugin || | || | || OVN Northbound DB || | || | || ovn-northd || …
阅读更多...
设置windows10资源管理器等的边框

设置windows10资源管理器等的边框

Windows10默认状态下&#xff0c;资源管理器、浏览器等没有边框&#xff0c;在打开多个窗口等情况下&#xff0c;想要拖动或选择某个窗口时&#xff0c;不是很好定位到窗口标题栏。 通过&#xff1a;设置&#xff08;可以通过wini组合键打开设置&#xff09;---》个性化 ---》…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023