【图论】【状态压缩】【树】【深度优先搜索】1617. 统计子树中城市之间最大距离

news2024/11/15 6:55:37

作者推荐

【动态规划】【字符串】【行程码】1531. 压缩字符串

本文涉及的知识点

图论 深度优先搜索 状态压缩 树

LeetCode1617. 统计子树中城市之间最大距离

给你 n 个城市，编号为从 1 到 n 。同时给你一个大小为 n-1 的数组 edges ，其中 edges[i] = [ui, vi] 表示城市 ui 和 vi 之间有一条双向边。题目保证任意城市之间只有唯一的一条路径。换句话说，所有城市形成了一棵 树 。
一棵 子树 是城市的一个子集，且子集中任意城市之间可以通过子集中的其他城市和边到达。两个子树被认为不一样的条件是至少有一个城市在其中一棵子树中存在，但在另一棵子树中不存在。
对于 d 从 1 到 n-1 ，请你找到城市间 最大距离 恰好为 d 的所有子树数目。
请你返回一个大小为 n-1 的数组，其中第 d 个元素（下标从 1 开始）是城市间 最大距离 恰好等于 d 的子树数目。
请注意，两个城市间距离定义为它们之间需要经过的边的数目。
示例 1：
输入：n = 4, edges = [[1,2],[2,3],[2,4]]
输出：[3,4,0]
解释：
子树 {1,2}, {2,3} 和 {2,4} 最大距离都是 1 。
子树 {1,2,3}, {1,2,4}, {2,3,4} 和 {1,2,3,4} 最大距离都为 2 。
不存在城市间最大距离为 3 的子树。
示例 2：
输入：n = 2, edges = [[1,2]]
输出：[1]
示例 3：
输入：n = 3, edges = [[1,2],[2,3]]
输出：[2,1]
提示：
2 <= n <= 15
edges.length == n-1
edges[i].length == 2
1 <= ui, vi <= n
题目保证 (ui, vi) 所表示的边互不相同。

深度优先搜索

编号从1到n，变成0到n-1。
枚举所有可能的子树mask，如果mask & (1 << i ) 表示第i个节点在此树中。
任意节点为根都可以，比如：0。

状态表示

m_vDis1[mask]记录 子树mask 以根节点为起点的最长路径经过的节点数。
m_vDis2[mask]记录子树mask 最长路径 经过的节点数。
非法子树两者都为0。

子树的的转移方程

子树的某合法状态：以它为根节点的子树。
枚举各子树的状态，处理独子树。独子树为mask，根节点为root，则当前树为：mask1 = mask | ( 1 << root)。
m_vDis1[mask1] = m_vDis1[mask]+1
m_vDis2[mask1] = max(m_vDis1[mask1] ,m_vDis2[mask])
处理非独子树
vLeft 记录根节点和前i棵子树 组成 的 所有合法字子树，如：mask1，第i棵子树的某合法状态 mask2。
两者合并后的新状态为mask3 = mask1 | mask2。
m_vDis1[mask3] = max(m_vDis1[mask1] ,m_vDis1[mask2]+1)
m_vDis2[mask3] = max(m_vDis2[mask1],m_vDis2[mask2],m_vDis1[mask1]+m_vDis1[mask2])

代码

核心代码

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<int> countSubgraphsForEachDiameter(int n, vector<vector<int>>& edges) {
		m_vDis1.resize((1 << n));
		m_vDis2.resize((1 << n));
		CNeiBo2 neibo(n, edges, false, 1);
		DFS(neibo.m_vNeiB, 0, -1);
		vector<int> vRet(n-1);
		for (int i = 0; i < (1 << n); i++)
		{
			const int inx = m_vDis2[i] - 2;
			if (inx >= 0)
			{
				vRet[inx]++;
			}
		}
		return vRet;
	}
	vector<int> DFS(vector<vector<int>>& neiBo,int cur,int par)
	{
		vector<int> statu;
		const int curMask = 1 << cur;
		statu.emplace_back(curMask);
		m_vDis1[curMask] = m_vDis2[curMask] = 1;
		for (const auto& next : neiBo[cur])
		{
			if (next == par)
			{
				continue;
			}
			auto child = DFS(neiBo, next, cur);			
			const int iLeftCount = statu.size();
			for(const auto& mask : child )
			{
				{//处理独子树
					const int mask1 = mask | curMask;
					m_vDis1[mask1] = m_vDis1[mask] + 1;
					m_vDis2[mask1] = max(m_vDis1[mask1], m_vDis2[mask]);
					statu.emplace_back(mask1);
				}
				{//非独子树
					for (int i = iLeftCount - 1; i >= 0; i--)
					{
						const int mask1 = mask | statu[i];
						m_vDis1[mask1] = max(m_vDis1[statu[i]], m_vDis1[mask] + 1);
						m_vDis2[mask1] = max(m_vDis2[statu[i]], m_vDis2[mask]);
						m_vDis2[mask1] = max(m_vDis2[mask1], m_vDis1[statu[i]]+ m_vDis1[mask]);
						statu.emplace_back(mask1);
					}
				}
			}
		}
		return statu;
	}
	vector<int> m_vDis1, m_vDis2;
};

测试用例

template<class T>
void Assert(const T& t1, const T& 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<vector<int>> edges;
	
	{
		Solution sln;
		n = 2, edges = { {1,2} };
		auto res = sln.countSubgraphsForEachDiameter(n, edges);
		Assert(res, vector<int>{1});
	}

	{
		Solution sln;
		n = 4, edges = { {1,2},{2,3},{2,4} };
		auto res = sln.countSubgraphsForEachDiameter(n, edges);
		Assert(res, vector<int>{3, 4, 0});
	}

	{
		Solution sln;
		n = 3, edges = { {1,2},{2,3} };
		auto res = sln.countSubgraphsForEachDiameter(n, edges);
		Assert(res, vector<int>{2,1});
	}
	
}

2023年2月

class Solution {
public:
vector countSubgraphsForEachDiameter(int n, vector<vector>& edges) {
m_n = n;
m_vNear.resize(n);
for (const auto& v : edges)
{
m_vNear[v[0] - 1].push_back(v[1] - 1);
m_vNear[v[1] - 1].push_back(v[0] - 1);
}
DFSForDelParent(0, -1);
BSFForNodeSort(0, -1);
m_vNodeLeveMaxDist.assign(n, vector< vector>(n + 1, vector(n + 1)));
for (auto it = m_vSortNode.rbegin(); it != m_vSortNode.rend(); ++it)
{
dfs(*it);
}
vector vRet;
for (int iMaxDis = 1; iMaxDis < n; iMaxDis++)
{
int iSum = 0;
for (int iNode = 0; iNode < n; iNode++)
{
for (int leve = 0; leve <= n; leve++)
{
iSum += m_vNodeLeveMaxDist[iNode][leve][iMaxDis + 1];
}
}
vRet.push_back(iSum);
}
return vRet;
}
void DFSForDelParent(int iCur, const int iParent)
{
auto& v = m_vNear[iCur];
for (auto it = v.begin(); it != v.end(); ++ it )
{
if (iParent == *it )
{
v.erase(it);
break;
}
}
for (auto it = v.begin(); it != v.end(); ++it)
{
DFSForDelParent(*it, iCur);
}
}
void BSFForNodeSort(int iCur, const int iParent)
{
m_vSortNode.push_back(iCur);
int iNotSubNode = m_vSortNode.size();
for (const auto& next : m_vNear[iCur])
{
m_vSortNode.push_back(next);
}
const int iNodeNum = m_vSortNode.size();
for (int i = iNotSubNode; i < iNodeNum; i++)
{
BSFForNodeSort(m_vSortNode[i], iCur);
}
}
void dfs(int iCur)
{
vector<vector> pre(m_n + 1, vector(m_n + 1));
pre[0+1][-1+1] = 1;
for (const auto& next : m_vNear[iCur])
{
vector<vector> dp(m_n + 1, vector(m_n + 1));
for (int iPreLeve = -1; iPreLeve < m_n; iPreLeve++)
{
for (int iPreMaxDis = -1; iPreMaxDis < m_n; iPreMaxDis++)
{
if (0 == pre[iPreLeve + 1][iPreMaxDis + 1])
{
continue;
}
for (int iLeve = -1; iLeve < m_n; iLeve++)
{
for (int iMaxDis = -1; iMaxDis < m_n; iMaxDis++)
{
if (0 == m_vNodeLeveMaxDist[next][iLeve + 1][iMaxDis + 1])
{
continue;
}
int iNewMaxDis = max(iPreMaxDis, max(iMaxDis, iLeve));
iNewMaxDis = max(iNewMaxDis, iPreLeve + iLeve+1 );
int iNewLeve = max(iPreLeve, iLeve + 1);
dp[iNewLeve + 1][iNewMaxDis + 1] += pre[iPreLeve + 1][iPreMaxDis + 1] * m_vNodeLeveMaxDist[next][iLeve + 1][iMaxDis + 1];
}
}
}
}
pre.swap(dp);
}
pre[-1 + 1][-1 + 1]++;
m_vNodeLeveMaxDist[iCur] = pre;
}
vector m_vSortNode;//根节点，一级节点，二级节点…
vector<vector> m_vNear;
vector<vector<vector>> m_vNodeLeveMaxDist;
int m_n;
};

2023年9月

class Solution {
public:
vector countSubgraphsForEachDiameter(int n, vector<vector>& edges) {
CNeiBo2 neiBo(n, edges, false, 1);
AssignVector3(m_vLeveNums,n,n,n,0);
dfs(0, -1, neiBo);
vector vRet(n - 1);
for (int Dis = 1; Dis < n; Dis++)
{
for (int node = 0; node < n; node++)
{
for (int leve = 0; leve < n; leve++)
{
vRet[Dis - 1] += m_vLeveNums[node][leve][Dis];
}
}
}
return vRet;
}
void dfs(int cur,int parent, CNeiBo2& neiBo)
{
m_vLeveNums[cur][0][0] = 1;
for (const auto& next : neiBo.m_vNeiB[cur])
{
if (next == parent)
{
continue;
}
dfs(next, cur, neiBo);
auto pre = m_vLeveNums[cur];
for (int preLeve = 0; preLeve < pre.size(); preLeve++)
{
for (int preDis = 0; preDis < pre.size(); preDis++)
{
for (int nextLeve = 0; nextLeve + 1 < pre.size(); nextLeve++)
{
for (int nextDis = 0; nextDis < pre.size(); nextDis++)
{
const int iNewLeve = max(nextLeve + 1, preLeve);
int iNewDis = max(preDis, preLeve + nextLeve + 1);
MaxSelf(&iNewDis, nextDis);
if (iNewDis >= pre.size())
{
continue;
}
m_vLeveNums[cur][iNewLeve][iNewDis] += pre[preLeve][preDis] * m_vLeveNums[next][nextLeve][nextDis];
}
}
}
}
}
}
vector<vector<vector>> m_vLeveNums;//m_vRet[cur][i][j]表示以cur为根 ，叶子距离cur最大距离为i,任意两个节点最大距离为j。m_vRet[cur][0][0]表示只有根节点
};

扩展阅读

视频课程

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

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

相关文章

在 Linux 中挂载新硬盘动态使用

在 Linux 中挂载新硬盘动态使用

目录 一&#xff1a;添加硬盘并且格式化 二&#xff1a;创建逻辑卷 三&#xff1a;挂载卷到目录 在 Linux 中挂载新硬盘并进行格式化的操作可以按照以下步骤进行&#xff1a; 一&#xff1a;添加硬盘并且格式化 查看现有分区状态和服务器安装的硬盘状态&#xff1a; df -…
阅读更多...
开源项目TARZAN-NAV | 基于springboot的现代化导航网站系统

开源项目TARZAN-NAV | 基于springboot的现代化导航网站系统

TARZAN-NAV 导航网站 一个基于 Spring Boot、MyBatis-Plus、h2database、ehcache、Docker、websocket等技术栈实现的导航网站系统&#xff0c;采用主流的互联网技术架构、全新的UI设计、支持一键源码部署&#xff0c;拥有完整的仪表板、导航管理&#xff0c;用户管理、评论管理…
阅读更多...
操作筛选器的 1 个应用实例：自动启用事务

操作筛选器的 1 个应用实例：自动启用事务

前言 在数据库操作过程中&#xff0c;有一个概念是绕不开的&#xff0c;那就是事务。 事务能够确保一系列数据库操作要么全部成功提交&#xff0c;要么全部失败回滚&#xff0c;保证数据的一致性和完整性。 在 Asp.Net Core Web API 中&#xff0c;我们可以使用操作筛选器给…
阅读更多...
uni-app小程序自定义导航栏

uni-app小程序自定义导航栏

最近在开发一个uni-app小程序&#xff0c;用到了自定义导航栏&#xff0c;在这里记录一下实现过程&#xff1a; page.json 在对应页面路由的style中设置入"navigationStyle": "custom"取消原生导航栏&#xff0c;自定义导航栏 {"path": "…
阅读更多...
C++ //练习 3.8 分别用while循环和传统的for循环重写第一题的程序，你觉得哪种形式更好呢？为什么?

C++ //练习 3.8 分别用while循环和传统的for循环重写第一题的程序，你觉得哪种形式更好呢？为什么?

C Primer&#xff08;第5版&#xff09; 练习 3.8 练习 3.8 分别用while循环和传统的for循环重写第一题的程序&#xff0c;你觉得哪种形式更好呢&#xff1f;为什么? 环境&#xff1a;Linux Ubuntu&#xff08;云服务器&#xff09; 工具&#xff1a;vim 代码块 /********…
阅读更多...
[晓理紫]每日论文分享(有源码或项目地址、中文摘要)--强化学习、模仿学习、机器人

[晓理紫]每日论文分享(有源码或项目地址、中文摘要)--强化学习、模仿学习、机器人

专属领域论文订阅 VX 关注{晓理紫}，每日更新论文，如感兴趣，请转发给有需要的同学，谢谢支持 如果你感觉对你有所帮助，请关注我，每日准时为你推送最新论文。 为了答谢各位网友的支持，从今日起免费为300名读者提供订阅主题论文服务，只需VX关注公号并回复{邮箱+论文主题}（…
阅读更多...
深度强化学习（王树森）笔记10

深度强化学习（王树森）笔记10

深度强化学习&#xff08;DRL&#xff09; 本文是学习笔记&#xff0c;如有侵权&#xff0c;请联系删除。本文在ChatGPT辅助下完成。 参考链接 Deep Reinforcement Learning官方链接&#xff1a;https://github.com/wangshusen/DRL 源代码链接&#xff1a;https://github.c…
阅读更多...
KAFKA高可用架构涉及常用功能整理

KAFKA高可用架构涉及常用功能整理

KAFKA高可用架构涉及常用功能整理 1. kafka的高可用系统架构和相关组件2. kafka的核心参数2.1 常规配置2.2 特殊优化配置 3. kafka常用命令3.1 常用基础命令3.1.1 创建topic3.1.2 获取集群的topic列表3.1.3 获取集群的topic详情3.1.4 删除集群的topic3.1.5 获取集群的消费组列表…
阅读更多...
如何使用 Google 搜索引擎保姆级教程（附链接）

如何使用 Google 搜索引擎保姆级教程（附链接）

一、介绍 "Google语法"通常是指在 Google 搜索引擎中使用一系列特定的搜索语法和操作符来精确地定义搜索查询。这些语法和操作符允许用户过滤和调整搜索结果&#xff0c;提高搜索的准确性。 二、安装 Google 下载 Google 浏览器 Google 官网https://www.google.c…
阅读更多...
Python||1. 使用LSTM模型进行乘客的数目预测；2.对文件rest-api-asr_python_audio_16k.m4a进行语音识别

Python||1. 使用LSTM模型进行乘客的数目预测；2.对文件rest-api-asr_python_audio_16k.m4a进行语音识别

1. 使用LSTM模型进行乘客的数目预测 数据集 international-airline-passengers.csv&#xff08;可以不在意精度和loss&#xff09; import pandas as pd import numpy as np filename rC:\Users\15002\Desktop\data1\international-airline-passengers.csv data pd.read_cs…
阅读更多...
科技云报道：新趋势下，国产数据库或“春山可望”

科技云报道：新趋势下，国产数据库或“春山可望”

科技云报道原创。 从540亿元到1286亿元——这是中国通信标准化协会大数据技术标准推进委员会针对中国数据库行业给出的一份预测报告。 报告指出&#xff0c;未来五年&#xff0c;中国数据库行业将从百亿级市场跨越成为千亿级市场。 最近两年&#xff0c;中国的数据库行业似乎…
阅读更多...
OAuth2的四种授权方式

OAuth2的四种授权方式

OAuth2的四种授权方式 OAuth2的作用OAuth2的四种授权方式OAuth2相关名词授权码模式授权码模式的步骤 简化模式简化模式的步骤 密码模式密码模式的步骤 客户端模式客户端模式的步骤 OAuth2的作用 核心作用&#xff1a;颁发token&#xff0c;也就是令牌&#xff0c;token中一般包…
阅读更多...
【DB2 流浪之旅】 第一讲 Linux 环境安装 db2 数据库

【DB2 流浪之旅】 第一讲 Linux 环境安装 db2 数据库

DB2数据库是IBM开发的一种大型关系型数据库平台。它支持多用户或应用程序在同一条SQL 语句中查询不同database甚至不同DBMS中的数据。一般DB2是搭配IBM Power系列小机使用的&#xff0c;兼容性好、性能高。当然DB2也有Linux版本的&#xff0c;相对性能会差一些&#xff0c;主要…
阅读更多...
密评机构资质和开展业务资料

密评机构资质和开展业务资料

一、概念 密码&#xff1a;《密码法》定义是指对信息进行加密保护、安全认证的技术、产品、服务。分为&#xff1a;核心密码、普通密码、商用密码。 商用密码&#xff1a;《密码法》定义是指对不涉及国家秘密内容的信息进行加密保护或安全认证所使用的密码技术和密码产品。 …
阅读更多...
JVM 内存模型

JVM 内存模型

1 什么是 JVM 内存模型 JVM 需要使用计算机的内存&#xff0c;Java 程序运行中所处理的对象或者算法都会使用 JVM 的内 存空间&#xff0c;JVM 将内存区划分为 5 块&#xff0c;这样的结构称之为 JVM 内存模型。 2 JVM 为什么进行内存区域划分 随着对象数量的增加&#xff…
阅读更多...
【Python机器学习系列】建立LightGBM模型预测心脏疾病（完整实现过程）

【Python机器学习系列】建立LightGBM模型预测心脏疾病（完整实现过程）

一、引言 前文回顾&#xff1a; 一文彻底搞懂机器学习中的归一化与反归一化问题 【Python机器学习系列】一文彻底搞懂机器学习中表格数据的输入形式&#xff08;理论源码&#xff09; 【Python机器学习系列】一文带你了解机器学习中的Pipeline管道机制&#xff08;理论源码…
阅读更多...
如何一键导出多张图片二维码？图片批量建码生成的方法

如何一键导出多张图片二维码？图片批量建码生成的方法

现在很多的物品信息都会生成一张单独的图片&#xff0c;然后生成二维码印刷到包装或者其他地方上使用&#xff0c;那么如何快速将多张图片多批量生码处理&#xff0c;相信有很多的小伙伴都不太清楚该怎么完成。其实&#xff0c;大量图片生成二维码的方法是很简单的&#xff0c;…
阅读更多...
MySQL默认的连接数151如何修改

MySQL默认的连接数151如何修改

在MySQL中修改 max_connections 的值可以通过以下几种方法进行&#xff1a; 1. 临时修改 可以通过MySQL命令行临时修改 max_connections 的值。这种修改直到下次MySQL服务重启时才会失效。要进行临时修改&#xff0c;可以使用以下命令&#xff1a; SET GLOBAL max_connectio…
阅读更多...
聊聊DoIP吧

聊聊DoIP吧

DoIP是啥？ DoIP代表"Diagnostic over Internet Protocol"，即互联网诊断协议。它是一种用于在车辆诊断中进行通信的网络协议。DoIP的目标是在现代汽车中实现高效的诊断和通信。通过使用互联网协议（IP）作为通信基础，DoIP使得诊断信息能够通过网络进行传输，从而提…
阅读更多...
【Go】微服务架构下实现etcd服务注册与服务发现

【Go】微服务架构下实现etcd服务注册与服务发现

中心网关&#xff1a;gateway 四个微服务&#xff1a;user、message、note、relationship 1 中心网关实现服务发现 1.1 设计EtcdDiscovery类 package entityimport ("context""fmt"clientv3 "go.etcd.io/etcd/client/v3""gonote/gatewa…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023