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

置顶 于 2024-06-24 07:00:00 发布
阅读量1.2k 收藏 37
点赞数 56
文章标签： 宽度优先 算法 力扣 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++**实现。

闻缺陷则喜何志丹
关注
  • 56
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 56
    评论
专栏目录
BFSK.zip_BFSK
09-24
BFSK Constellation, Symbol error rate
bfs.zip_共轭梯度法
09-24
共轭梯度法计算线性方程组的代码。本段代码采用了F90的风格书写。注意共轭梯度法只适用于对称正定的矩阵。
树形dp小总结（换根，基环树，杂七杂八的dp）
sophilex的博客
07-28 482
脑子是个好东西，可惜我有的不多。。。从小到大都是看见树就头皮发麻，前阵子学的多了稍微好一点，但是经过一个树专题的洗礼，熟悉的恐惧感又回来了。。。会讲一下换根dp，基环树dp，也许后面还会更一下树上背包之类的换根换根，就是对不同节点做根的情况进行讨论，通常就是在一些节点选择的题目里会出现，但是碰到的不多（lwh简单的不会考，难的，你们。。。.....................
[python刷题模板] 树的直径/换根DP
liuliangcan的博客
01-22 1721
py刷题模板之树的直径/换根DP
11.动态规划：树形DP问题、树上最大独立集、树上最小支配集、换根DP、树上倍增（LCA）【灵神基础精讲】
qq_42958831的博客
06-05 1610
来源0x3f：https://space.bilibili.com/206214
树形dp问题讲解
m0_62289159的博客
03-23 117
树形dp的一些问题
【动态规划 & 树形dp】Tree DP ~~~详解
繁星之空～China锦鲤的博客
07-29 416
树形动态规划 (Tree DP) 是一种常用的动态规划技巧，跟普通的线性动态规划不同，此算法将DP建立在树状结构或图的基础上，是一种 DP 的思想。以下是树形 DP①、定义状态：根据问题的特点，定义每个节点需要保存的状态。可以是最大值、最小值、累加和、路径长度等等。②、设计转移方程：根据问题的要求，定义每个节点状态之间的转移关系。这个转移关系通常由树的拓扑结构决定，先在每个节点处定义状态，再利用已经计算出的节点状态来计算当前节点的状态。③、遍历计算：使用深度优先搜索 （DFS）或广度优先搜索（BFS遍历。
树形dp
weixin_43827530的博客
12-02 267
树形dp 准备工作： 邻接链表建边 动态规划找转移方程 邻接链表建边： 资料：邻接链表的构建详解【头插法&&尾插法】 https://blog.csdn.net/qq_36345036/article/details/76976157?fps=1&locationNum=3 一下来自这个博主： 头插法 头插法是用结构体数组来实现的。 具体的思路是:在建立邻接表时，记录的不是点而是边，对于每一个点所对应的邻接表都是以栈的形式存储的，也就是说先添加的边在遍历时后取出，除此以外，所有
树形dp相关
weixin_30886233的博客
08-08 211
前言 1：与树或图的生成树相关的动态规划。 2：以每棵子树为子结构，在父亲节点合并，注意树具有天然的子结构。这是很优美的很利于dp的。 3：巧妙利用Bfs或Dfs序，可以优化问题，或得到好的解决方法。 4：可以与树上的数据结构相结合。 5：树形Dp的时间复杂度要认真计算，部分问题可以均摊复杂度分析。 6：一般设f[u]表示u子树的最优价值或者是说方案数。 或者\(f[u][k]\)表示u...
初涉树形dp
weixin_30354675的博客
06-29 109
算是一个……复习以及进阶？ 什么是树形dp 树形dp是一种奇妙的dp…… 它的一个重要拓展是和各种树形的数据结构结合，比如说在trie上、自动机上的dp。 而且有些时候还可以拓展到环加外向树、仙人掌上的酷炫操作。 好吧上面这些我都不会。 树形dp的例题 【简单dp】P2015 二叉苹果树 题目描述 有一棵苹果树，如果树枝有分叉，一定是分2叉（就是说没有只有1个儿子的结点）...
树形动态规划题集
帅比王的博客
01-10 1212
测试地址 部分题面可能复制有问题，图片没有复制，有疑惑见原题面。 1575：【例 1】二叉苹果树 问题描述 有一棵二叉苹果树，如果数字有分叉，一定是分两叉，即没有只有一个儿子的节点。这棵树共 N 个节点，标号 1 至 N，树根编号一定为 1。 我们用一根树枝两端连接的节点编号描述一根树枝的位置。一棵有四根树枝的苹果树，因为树枝太多了，需要剪枝。但是一些树枝上长有苹果，给定需要保留的树枝数量，求最多...
BFSK.rar_BFSK_BFSK simulink
09-14
在simulink中搭建的BFSK模块，供大家参考
erchashu.rar_bfs_erchashu_树的 深度优先 广度优先
09-23
本文利用C语言实现了简单的二叉树，每个结点只保存一个整数，并且，由于非常简单，树的根结点是确定的，而不是输入的。确定根结点以后，用户输入的每一个数都被insert到树中（-999表示停止），利用深度优先的方法。...
BFSK.rar_bfsk怎么实现_bpsk仿真
09-14
BPSK仿真实现，适合初学者学习MATLAB仿真，简单易懂
算法力扣刷题记录六【203移除链表元素】
danaaaa的博客
06-21 1076
删除链表节点
189.二叉树：将有序数组转换为二叉搜索树（力扣）
weixin_63779802的博客
06-21 209
代码使用了递归的方法。主要思路是首先找到数组的中间元素，然后以这个中间元素作为根节点，递归地在数组中构建左右子树。左子树包含数组中所有小于中间元素的元素，右子树包含所有大于中间元素的元素。这个算法的时间复杂度是 O(n)，其中 n 是数组中元素的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。
面试+算法之回文(Java)：验证回文串、回文数、最长回文子串、回文链表、分割成回文串、最短回文串、
lonelymanontheway的博客
06-20 523
验证回文串、回文数、最长回文子串、分割成回文串、最短回文串、回文链表
【算法】二叉树 - 理论基础
最新发布
Nanki_的博客
06-23 1123
int val;
1将树形结构转换成一维数组
06-09
将树形结构转换成一维数组可以采用广度优先搜索（BFS）或深度优先搜索（DFS）算法。以下是采用DFS算法的示例代码： ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

闻缺陷则喜何志丹

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

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

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

打赏作者

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

抵扣说明：

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

余额充值