【树形dp 换根法 BFS】2581. 统计可能的树根数目

最新推荐文章于 2024-11-12 12:29:51 发布
最新推荐文章于 2024-11-12 12:29:51 发布
阅读量1.3k 收藏 37
点赞数 57
文章标签： 宽度优先 算法 力扣 c++ 树形dp 换根法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he_zhidan/article/details/139874100
版权

本文涉及知识点

C++BFS算法
动态规划汇总
图论知识汇总
树形dp 换根法 BFS

LeetCode 2581. 统计可能的树根数目

Alice 有一棵 n 个节点的树，节点编号为 0 到 n - 1 。树用一个长度为 n - 1 的二维整数数组 edges 表示，其中 edges[i] = [ai, bi] ，表示树中节点 ai 和 bi 之间有一条边。
Alice 想要 Bob 找到这棵树的根。她允许 Bob 对这棵树进行若干次 猜测 。每一次猜测，Bob 做如下事情：
选择两个 不相等 的整数 u 和 v ，且树中必须存在边 [u, v] 。
Bob 猜测树中 u 是 v 的 父节点 。
Bob 的猜测用二维整数数组 guesses 表示，其中 guesses[j] = [uj, vj] 表示 Bob 猜 uj 是 vj 的父节点。
Alice 非常懒，她不想逐个回答 Bob 的猜测，只告诉 Bob 这些猜测里面 至少 有 k 个猜测的结果为 true 。
给你二维整数数组 edges ，Bob 的所有猜测和整数 k ，请你返回可能成为树根的 节点数目 。如果没有这样的树，则返回 0。
示例 1：
输入：edges = [[0,1],[1,2],[1,3],[4,2]], guesses = [[1,3],[0,1],[1,0],[2,4]], k = 3
输出：3
解释：
根为节点 0 ，正确的猜测为 [1,3], [0,1], [2,4]
根为节点 1 ，正确的猜测为 [1,3], [1,0], [2,4]
根为节点 2 ，正确的猜测为 [1,3], [1,0], [2,4]
根为节点 3 ，正确的猜测为 [1,0], [2,4]
根为节点 4 ，正确的猜测为 [1,3], [1,0]
节点 0 ，1 或 2 为根时，可以得到 3 个正确的猜测。
示例 2：
输入：edges = [[0,1],[1,2],[2,3],[3,4]], guesses = [[1,0],[3,4],[2,1],[3,2]], k = 1
输出：5
解释：
根为节点 0 ，正确的猜测为 [3,4]
根为节点 1 ，正确的猜测为 [1,0], [3,4]
根为节点 2 ，正确的猜测为 [1,0], [2,1], [3,4]
根为节点 3 ，正确的猜测为 [1,0], [2,1], [3,2], [3,4]
根为节点 4 ，正确的猜测为 [1,0], [2,1], [3,2]
任何节点为根，都至少有 1 个正确的猜测。
提示：
edges.length == n - 1
2 <= n <= 105
1 <= guesses.length <= 105
0 <= ai, bi, uj, vj <= n - 1
ai != bi
uj != vj
edges 表示一棵有效的树。
guesses[j] 是树中的一条边。
guesses 是唯一的。
0 <= k <= guesses.length

换根法

某棵有根树，根为root，某个儿子为child，则将根从root换成child后，除 r o o t ↔ c h i l d root\leftrightarrow child root↔child这条的边的父子关系发生变化外，其它都不边。
mGuesss[x] 记录猜测次数:x=Mask(r,v) = u*n+v
x1 = Mask(root,child)
x2 = Mask(child,root)
则 dp[child] = dp[root] - mGuesss[x1] + mGuress[x2]
分三步：
一，令root为0,计算m_dp[0]。
二，dfs各节点计算m_dp[cur]。
三，统计m_dp中为k的元素数量。

动态规划的状态表示

m_dp[cur]表示以cur为根据猜对父子关系的数量。
空间复杂度: O(n)

动态规划的转移方程

dp[child] = dp[root] - mGuesss[x1] + mGuress[x2]
单个状态的转移方程时间复杂度：O(1) 总时间复杂度：O(n)

动态规划的初始值

dp[0]先计算

动态规划的填表顺序

深度优先，广度优先也可以。

动态规划的返回值

cout(dp.being(),dp.end(),k)

代码（超时)

核心代码

class CNeiBo
{
public:	
	static vector<vector<int>> Two(int n, vector<vector<int>>& edges, bool bDirect, int iBase = 0) 
	{
		vector<vector<int>>  vNeiBo(n);
		for (const auto& v : edges)
		{
			vNeiBo[v[0] - iBase].emplace_back(v[1] - iBase);
			if (!bDirect)
			{
				vNeiBo[v[1] - iBase].emplace_back(v[0] - iBase);
			}
		}
		return vNeiBo;
	}	
	static vector<vector<std::pair<int, int>>> Three(int n, vector<vector<int>>& edges, bool bDirect, int iBase = 0)
	{
		vector<vector<std::pair<int, int>>> vNeiBo(n);
		for (const auto& v : edges)
		{
			vNeiBo[v[0] - iBase].emplace_back(v[1] - iBase, v[2]);
			if (!bDirect)
			{
				vNeiBo[v[1] - iBase].emplace_back(v[0] - iBase, v[2]);
			}
		}
		return vNeiBo;
	}
	static vector<vector<int>> Grid(int rCount, int cCount, std::function<bool(int, int)> funVilidCur, std::function<bool(int, int)> funVilidNext)
	{
		vector<vector<int>> vNeiBo(rCount * cCount);
		auto Move = [&](int preR, int preC, int r, int c)
		{
			if ((r < 0) || (r >= rCount))
			{
				return;
			}
			if ((c < 0) || (c >= cCount))

			{
				return;
			}
			if (funVilidCur(preR, preC) && funVilidNext(r, c))
			{
				vNeiBo[cCount * preR + preC].emplace_back(r * cCount + c);
			}
		};

		for (int r = 0; r < rCount; r++)
		{
			for (int c = 0; c < cCount; c++)
			{
				Move(r, c, r + 1, c);
				Move(r, c, r - 1, c);
				Move(r, c, r, c + 1);
				Move(r, c, r, c - 1);
			}
		}
		return vNeiBo;
	}
	static vector<vector<int>> Mat(vector<vector<int>>& neiBoMat)
	{
		vector<vector<int>> neiBo(neiBoMat.size());
		for (int i = 0; i < neiBoMat.size(); i++)
		{
			for (int j = i + 1; j < neiBoMat.size(); j++)
			{
				if (neiBoMat[i][j])
				{
					neiBo[i].emplace_back(j);
					neiBo[j].emplace_back(i);
				}
			}
		}
		return neiBo;
	}
};


class Solution {
public:
	int rootCount(vector<vector<int>>& edges, vector<vector<int>>& guesses, int k) {
		m_c = edges.size() + 1;
		m_dp.resize(m_c);
		m_vNeiBo = CNeiBo::Two(m_c, edges, false);
		for (const auto& v : guesses) {
			m_mGuess[Mask(v[0], v[1])]++;
		}
		m_dp[0] = DFS1(0, -1);
		DFS2(0, -1);
		return count_if(m_dp.begin(), m_dp.end(), [&](int i) {return i >= k; });
	}
	int DFS1(int cur, int par) {
		int ret = 0;
		if (-1 != par) { 
			ret += m_mGuess[Mask(par, cur)];
		}
		for (const auto& next : m_vNeiBo[cur]) {
			if (next == par) { continue; }
			ret += DFS1(next, cur);
		}
		return ret;
	}
	void DFS2(int cur, int par) {
		if (-1 != par) {
			m_dp[cur] = m_dp[par];
			m_dp[cur] -= m_mGuess[Mask(par, cur)];
			m_dp[cur] += m_mGuess[Mask(cur, par)];
		}	
		for (const auto& next : m_vNeiBo[cur]) {
			if (next == par) { continue; }
			DFS2(next, cur);
		}
	}
	long long Mask(long long par, int cur) { return m_c * par + cur; }
	int m_c;
	vector<int> m_dp;
	unordered_map<long long, int> m_mGuess;
	vector < vector <int>> m_vNeiBo;
};

单元测试

template<class T1, class T2>
void AssertEx(const T1& t1, const T2& t2)
{
	Assert::AreEqual(t1, t2);
}

template<class T>
void AssertEx(const vector<T>& v1, const vector<T>& v2)
{
	Assert::AreEqual(v1.size(), v2.size());
	for (int i = 0; i < v1.size(); i++)
	{
		Assert::AreEqual(v1[i], v2[i]);
	}
}

template<class T>
void AssertV2(vector<vector<T>> vv1, vector<vector<T>> vv2)
{
	sort(vv1.begin(), vv1.end());
	sort(vv2.begin(), vv2.end());
	Assert::AreEqual(vv1.size(), vv2.size());
	for (int i = 0; i < vv1.size(); i++)
	{
		AssertEx(vv1[i], vv2[i]);
	}
}

namespace UnitTest
{
	vector<vector<int>> edges, guesses;
	int k;
	TEST_CLASS(UnitTest)
	{
	public:
		TEST_METHOD(TestMethod0)
		{
			edges = { {0,1},{1,2},{1,3},{4,2} }, guesses = { {1,3},{0,1},{1,0},{2,4} }, k = 3;
			auto res = Solution().rootCount(edges, guesses, k);
			AssertEx(3, res);
		}
		TEST_METHOD(TestMethod1)
		{
			edges = { {0,1},{1,2},{2,3},{3,4} }, guesses = { {1,0},{3,4},{2,1},{3,2} }, k = 1;
			auto res = Solution().rootCount(edges, guesses, k);
			AssertEx(5, res);
		}
		TEST_METHOD(TestMethod2)
		{
			edges =
			{ {1,0},{2,1},{2,3},{4,0},{5,2},{6,1},{0,7},{1,8},{9,6},{10,4},{11,10},{12,8},{8,13},{14,4},{15,9},{9,16},{3,17},{4,18},{6,19},{20,13},{21,20},{19,22},{23,3},{24,0},{25,14},{17,26},{27,3},{3,28},{29,3},{4,30},{31,9},{0,32},{33,12},{34,14},{27,35},{35,36},{37,33},{38,18},{6,39} };
			guesses =
			{ {13,8},{4,18},{37,33},{4,30},{1,8},{3,17},{25,14},{0,1},{27,35},{21,20},{6,1},{26,17},{1,2},{8,13},{22,19},{30,4},{4,0},{2,5},{14,4},{9,6},{19,22},{16,9},{5,2},{29,3},{34,14},{8,1},{11,10},{15,9},{10,4},{35,27},{3,27},{33,12},{14,34},{32,0},{14,25},{39,6},{7,0},{4,10},{0,32},{23,3},{20,21},{24,0},{0,7},{1,0},{3,28},{6,9},{8,12},{18,4},{1,6},{2,1},{2,3},{3,29},{9,16},{17,26},{35,36},{13,20},{10,11},{18,38},{3,23},{0,24},{33,37},{12,33},{3,2},{20,13},{17,3} };
				k =	29;
			auto res = Solution().rootCount(edges, guesses, k);
			AssertEx(40, res);
		}
	};
}

DFS非常容易超时

DFS稍稍复杂，leetcode就容易超时。
所以：
一，计算出临接表。
二，DFS各节点层次。
三，计算出各节点的孩子。
四，BFS各节点。由于每个节点顶多一个父亲，所以无需判断节点是否重复访问。



class CNeiBo
{
public:	
	static vector<vector<int>> Two(int n, vector<vector<int>>& edges, bool bDirect, int iBase = 0) 
	{
		vector<vector<int>>  vNeiBo(n);
		for (const auto& v : edges)
		{
			vNeiBo[v[0] - iBase].emplace_back(v[1] - iBase);
			if (!bDirect)
			{
				vNeiBo[v[1] - iBase].emplace_back(v[0] - iBase);
			}
		}
		return vNeiBo;
	}	
	static vector<vector<std::pair<int, int>>> Three(int n, vector<vector<int>>& edges, bool bDirect, int iBase = 0)
	{
		vector<vector<std::pair<int, int>>> vNeiBo(n);
		for (const auto& v : edges)
		{
			vNeiBo[v[0] - iBase].emplace_back(v[1] - iBase, v[2]);
			if (!bDirect)
			{
				vNeiBo[v[1] - iBase].emplace_back(v[0] - iBase, v[2]);
			}
		}
		return vNeiBo;
	}
	static vector<vector<int>> Grid(int rCount, int cCount, std::function<bool(int, int)> funVilidCur, std::function<bool(int, int)> funVilidNext)
	{
		vector<vector<int>> vNeiBo(rCount * cCount);
		auto Move = [&](int preR, int preC, int r, int c)
		{
			if ((r < 0) || (r >= rCount))
			{
				return;
			}
			if ((c < 0) || (c >= cCount))

			{
				return;
			}
			if (funVilidCur(preR, preC) && funVilidNext(r, c))
			{
				vNeiBo[cCount * preR + preC].emplace_back(r * cCount + c);
			}
		};

		for (int r = 0; r < rCount; r++)
		{
			for (int c = 0; c < cCount; c++)
			{
				Move(r, c, r + 1, c);
				Move(r, c, r - 1, c);
				Move(r, c, r, c + 1);
				Move(r, c, r, c - 1);
			}
		}
		return vNeiBo;
	}
	static vector<vector<int>> Mat(vector<vector<int>>& neiBoMat)
	{
		vector<vector<int>> neiBo(neiBoMat.size());
		for (int i = 0; i < neiBoMat.size(); i++)
		{
			for (int j = i + 1; j < neiBoMat.size(); j++)
			{
				if (neiBoMat[i][j])
				{
					neiBo[i].emplace_back(j);
					neiBo[j].emplace_back(i);
				}
			}
		}
		return neiBo;
	}
};




class CDFSLeveChild
{
public:
	CDFSLeveChild(const vector<vector <int>>& vNeiBo,int root=0):m_vNeiBo(vNeiBo), Leve(m_vLeve){
		m_vLeve.resize(m_vNeiBo.size());
		DFS(root, -1);
	};
	const vector<int>& Leve;
	vector<vector<int>> Child() const{
		vector<vector <int>> vChild(m_vNeiBo.size());
		for (int i = 0; i < m_vNeiBo.size(); i++) {
			for (const auto& next : m_vNeiBo[i]) {
				if (m_vLeve[next] < m_vLeve[i]) { continue; }
				vChild[i].emplace_back(next);
			}
		}
		return vChild;
	}
protected:
	void DFS(int cur, int par) {
		if (-1 != par) { m_vLeve[cur] = m_vLeve[par] + 1; }
		for (const auto& next : m_vNeiBo[cur]) {
			if (next == par) { continue; }
			DFS(next, cur);
		}
	}
	vector<int> m_vLeve;
	const vector<vector <int>>& m_vNeiBo;
};
class Solution {
public:
	int rootCount(vector<vector<int>>& edges, vector<vector<int>>& guesses, int k) {
		m_c = edges.size() + 1;
		m_dp.resize(m_c);		
		m_vNeiBo = CNeiBo::Two(m_c, edges, false);		
		auto vChilds = CDFSLeveChild(m_vNeiBo).Child();
		for (const auto& v : guesses) {
			m_mGuess[Mask(v[0], v[1])]++;
		}
		for (int par = 0; par < m_c; par++) {
			for (int& child : vChilds[par]) {
				m_dp[0] += m_mGuess[Mask(par, child)];
			}
		}	
		queue<int> que;		
		que.emplace(0);
		while (que.size()) {
			int cur = que.front();
			que.pop();
			for (const auto& child : vChilds[cur]) {
				m_dp[child] = m_dp[cur];
				m_dp[child] -= m_mGuess[Mask(cur, child)];
				m_dp[child] += m_mGuess[Mask(child, cur)];
				que.emplace(child);
			}
		}
		return count_if(m_dp.begin(), m_dp.end(), [&](int i) {return i >= k; });
	}
	long long Mask(long long par, int cur) { return m_c * par + cur; }
	int m_c;
	vector<int> m_dp;
	unordered_map<long long, int> m_mGuess;
	vector < vector <int>> m_vNeiBo;	
};

进一步优化

可以用数组代码映射，算法方向，总共2n-2条边。假定根为0的树。
如果这条边是 子节点执行父节点，则此边数是child。如果方向相反则是n + child。
运行速度大约提高了20%。

class Solution {
public:
	int rootCount(vector<vector<int>>& edges, vector<vector<int>>& guesses, int k) {
		m_c = edges.size() + 1;
		m_dp.resize(m_c);	
		vector<int> vGuess(m_c * 2);
		m_vNeiBo = CNeiBo::Two(m_c, edges, false);	
		CDFSLeveChild dfs(m_vNeiBo);
		auto vChilds = dfs.Child();
		auto Mask = [&](int par, int child) {
			if (dfs.Leve[par] < dfs.Leve[child]) {
				return child;
			}
			return par + m_c;
		};
		for (const auto& v : guesses) {
			vGuess[Mask(v[0], v[1])]++;
		}
		for (int par = 0; par < m_c; par++) {
			for (int& child : vChilds[par]) {
				m_dp[0] += vGuess[Mask(par, child)];
			}
		}	
		queue<int> que;		
		que.emplace(0);
		while (que.size()) {
			int cur = que.front();
			que.pop();
			for (const auto& child : vChilds[cur]) {
				m_dp[child] = m_dp[cur];
				m_dp[child] -= vGuess[Mask(cur, child)];
				m_dp[child] += vGuess[Mask(child, cur)];
				que.emplace(child);
			}
		}
		return count_if(m_dp.begin(), m_dp.end(), [&](int i) {return i >= k; });
	}
	
	int m_c;
	vector<int> m_dp;	
	vector < vector <int>> m_vNeiBo;	
};

DFS序+差分数组

root和它的某个后代childchild换根。则到 c h i l d c h i l d ↔ r o o t childchild\leftrightarrow root childchild↔root这条路径上的边都反转。可以用差分数组。
childchild和它的祖先不是连续的，但他们的DFS序是连续的。
此方案不好理解，实现也不简单。备用。

扩展阅读

视频课程

先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

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

相关推荐

我想对大家说的话
《喜缺全书算法册》以原理、正确性证明、总结为主。
按类别查阅鄙人的算法文章，请点击《算法与数据汇总》。
有效学习：明确的目标 及时的反馈 拉伸区（难度合适） 专注
闻缺陷则喜(喜缺)是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

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

闻缺陷则喜何志丹
关注
专栏目录
树形dp小总结（换根，基环树，杂七杂八的dp）
sophilex的博客
07-28 593
脑子是个好东西，可惜我有的不多。。。从小到大都是看见树就头皮发麻，前阵子学的多了稍微好一点，但是经过一个树专题的洗礼，熟悉的恐惧感又回来了。。。会讲一下换根dp，基环树dp，也许后面还会更一下树上背包之类的换根换根，就是对不同节点做根的情况进行讨论，通常就是在一些节点选择的题目里会出现，但是碰到的不多（lwh简单的不会考，难的，你们。。。.....................
[python刷题模板] 树的直径/换根DP
liuliangcan的博客
01-22 1874
py刷题模板之树的直径/换根DP
树形dp问题讲解
m0_62289159的博客
03-23 184
树形dp的一些问题
11.动态规划：树形DP问题、树上最大独立集、树上最小支配集、换根DP、树上倍增（LCA）【灵神基础精讲】
qq_42958831的博客
06-05 3124
来源0x3f：https://space.bilibili.com/206214
【动态规划 & 树形dp】Tree DP ~~~详解
繁星之空～China锦鲤的博客
07-29 567
树形动态规划 (Tree DP) 是一种常用的动态规划技巧，跟普通的线性动态规划不同，此算法将DP建立在树状结构或图的基础上，是一种 DP 的思想。以下是树形 DP①、定义状态：根据问题的特点，定义每个节点需要保存的状态。可以是最大值、最小值、累加和、路径长度等等。②、设计转移方程：根据问题的要求，定义每个节点状态之间的转移关系。这个转移关系通常由树的拓扑结构决定，先在每个节点处定义状态，再利用已经计算出的节点状态来计算当前节点的状态。③、遍历计算：使用深度优先搜索 （DFS）或广度优先搜索（BFS遍历。
树形dp
weixin_43827530的博客
12-02 312
树形dp 准备工作： 邻接链表建边 动态规划找转移方程 邻接链表建边： 资料：邻接链表的构建详解【头插法&&尾插法】 https://blog.csdn.net/qq_36345036/article/details/76976157?fps=1&locationNum=3 一下来自这个博主： 头插法 头插法是用结构体数组来实现的。 具体的思路是:在建立邻接表时，记录的不是点而是边，对于每一个点所对应的邻接表都是以栈的形式存储的，也就是说先添加的边在遍历时后取出，除此以外，所有
树形dp相关
weixin_30886233的博客
08-08 247
前言 1：与树或图的生成树相关的动态规划。 2：以每棵子树为子结构，在父亲节点合并，注意树具有天然的子结构。这是很优美的很利于dp的。 3：巧妙利用Bfs或Dfs序，可以优化问题，或得到好的解决方法。 4：可以与树上的数据结构相结合。 5：树形Dp的时间复杂度要认真计算，部分问题可以均摊复杂度分析。 6：一般设f[u]表示u子树的最优价值或者是说方案数。 或者\(f[u][k]\)表示u...
初涉树形dp
weixin_30354675的博客
06-29 150
算是一个……复习以及进阶？ 什么是树形dp 树形dp是一种奇妙的dp…… 它的一个重要拓展是和各种树形的数据结构结合，比如说在trie上、自动机上的dp。 而且有些时候还可以拓展到环加外向树、仙人掌上的酷炫操作。 好吧上面这些我都不会。 树形dp的例题 【简单dp】P2015 二叉苹果树 题目描述 有一棵苹果树，如果树枝有分叉，一定是分2叉（就是说没有只有1个儿子的结点）...
树形动态规划题集
帅比王的博客
01-10 1291
测试地址 部分题面可能复制有问题，图片没有复制，有疑惑见原题面。 1575：【例 1】二叉苹果树 问题描述 有一棵二叉苹果树，如果数字有分叉，一定是分两叉，即没有只有一个儿子的节点。这棵树共 N 个节点，标号 1 至 N，树根编号一定为 1。 我们用一根树枝两端连接的节点编号描述一根树枝的位置。一棵有四根树枝的苹果树，因为树枝太多了，需要剪枝。但是一些树枝上长有苹果，给定需要保留的树枝数量，求最多...
树形DP（动态规划）.pptx
01-12
树形动态规划（Tree Dynamic Programming, 简称树形DP）是一种在树结构上进行优化决策的方法，常用于解决与树形结构相关的最优化问题。在这个特定的问题中，我们面临的是一个聚会组织的问题，目标是找到使得幽默系数...
树上问题1-树形DP-PPT.pptx
08-09
在实际应用中，树形DP可能需要结合剪枝策略来避免重复计算，提高效率。例如，可以使用记忆化搜索来存储已经计算过的子问题的结果，从而减少计算量。 总结来说，树形DP是一种在树结构上优化计算的技术，它通过定义...
BFSK.rar_BFSK_BFSK simulink
09-14
**标题解析：** "BFSK.rar_BFSK_BFSK simulink" 指的是一个与BFSK（Binary Frequency Shift Keying，二进制频移键控）相关的Simulink模型，它被压缩在名为"BFSK.rar"的文件中。文件名中的"_BFSK"可能是重复强调主题...
算法进阶02.zip 树形dp问题
06-20
学习树形DP，首先要熟悉树的基本操作，如遍历（深度优先搜索DFS和广度优先搜索BFS）、树的构建和查询等。其次，理解动态规划的基本思想，掌握如何将问题分解为子问题并进行状态转移。最后，通过实践解决各种树形DP...
bfsk.rar_BFSK_BFSK 白噪声_BFSK 高斯_BFSK信号
09-19
“bfsk.rar_BFSK_BFSK 白噪声_BFSK 高斯_BFSK信号”这个标题提到了几个关键概念，首先，“BFSK”是二进制频率移键控（Binary Frequency Shift Keying）的缩写，这是一种常见的模拟调制技术，用于数字信号的无线传输...
PCA（主成分分析）算法的应用场景
huanfeng_AI的博客
11-09 537
需要注意的是，PCA并不适用于所有场景。例如，当数据之间存在非线性关系时，PCA可能无法完全揭示数据的内在结构。此外，PCA对初始变量的顺序和标签敏感，不同的变量顺序可能导致不同的主成分结果。因此，在选择数据分析方法时，需要根据具体的数据和任务需求来决定是否使用PCA。
STL set
hls0611的博客
11-09 251
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
0-Equity-Transformer：求解NP-Hard Min-Max路由问题的顺序生成算法（AAAI-24)(完)（code）
最新发布
太极生两鱼
11-12 85
最小最大路由问题旨在通过智能体合作完成任务来最小化多个智能体中最长行程的长度。这些问题包括对现实世界有重大影响的应用场景，但已知属于NP-hard问题。现有方法在大规模问题上面临挑战，尤其是在需要协调大量智能体以覆盖数千个城市的情况下。本文提出了Equity-Transformer来解决大规模最小最大路由问题。首先，我们采用顺序规划方法来处理最小最大路由问题，使我们能够利用强大的序列生成器（例如，Transformer）。其次，我们提出了关键的归纳偏差，以确保智能体之间的公平工作量分配。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1462
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
算法每日双题精讲——双指针（有效三角形的个数，和为s的俩个数）
A Charmer 的博客
11-09 1257
本文围绕算法中的双指针技巧，详细讲解了 “有效三角形的个数” 和 “和为 s 的俩个数” 两道题目。对于 “有效三角形的个数”，通过排序数组后利用双指针遍历统计满足条件的三元组；“和为 s 的俩个数” 则是先排序，再用双指针找到和为目标值的两个数的下标。文中给出了 C++ 代码实现，并分析了每道题的时间复杂度和空间复杂度，最后强调双指针算法在解决数组问题中的优势，鼓励读者在算法学习中掌握该技巧。
树形DP深度解析：递归与策略优化
树形DP的状态通常由根节点、子树资源分配情况、以及选择或非选择的状态标志（如0/1表示）构成。这种组合状态使得问题可以分解为独立处理子树的过程，而忽略树的结构差异（在没有资源分配的情况下，二叉树和多叉树...
评论 57
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闻缺陷则喜何志丹

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值