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

本文涉及知识点

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++**实现。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

LoRaWAN在嵌入式网络通信中的应用：打造高效远程监控系统(附代码示例)

LoRaWAN在嵌入式网络通信中的应用：打造高效远程监控系统(附代码示例)

引言 随着物联网&#xff08;IoT&#xff09;技术的发展&#xff0c;远程监控系统在各个领域的应用越来越广泛。LoRaWAN&#xff08;Long Range Wide Area Network&#xff09;作为一种低功耗广域网通信协议&#xff0c;因其长距离传输、低功耗和高可靠性等特点&#xff0c;成为…
阅读更多...
Apollo9.0 PNC源码学习之Planning模块（二）—— planning_component

Apollo9.0 PNC源码学习之Planning模块（二）—— planning_component

前面文章： Apollo9.0 PNC源码学习之Planning模块（一）—— 规划概览 0 Planning代码框架速览 1 planning_component源码解析 modules/planning/planning_component/planning_component.h #pragma once#include <memory>#
阅读更多...
在vue项目中集成cesium

在vue项目中集成cesium

首先创建一个新的vue项目 安装vite中cesium插件 https://github.com/nshen/vite-plugin-cesium 安装插件 npm i cesium vite-plugin-cesium vite -D配置插件 注释原有样式 修改代码 效果
阅读更多...
04--MySQL8.0_JDBC

04--MySQL8.0_JDBC

第一章 JDBC概述 之前我们学习了JavaSE，编写了Java程序，数据保存在变量、数组、集合等中，无法持久化，后来学习了IO流可以将数据写入文件，但不方便管理数据以及维护数据的关系； 后来我们学习了数据库管理软件MySQL，可以方便的管理数据1。 那么如何将它俩结合起来呢？即…
阅读更多...
【面试干货】Java中的四种引用类型：强引用、软引用、弱引用和虚引用

【面试干货】Java中的四种引用类型：强引用、软引用、弱引用和虚引用

【面试干货】Java中的四种引用类型&#xff1a;强引用、软引用、弱引用和虚引用 1、强引用&#xff08;Strong Reference&#xff09;2、软引用&#xff08;Soft Reference&#xff09;3、弱引用&#xff08;Weak Reference&#xff09;4、虚引用&#xff08;Phantom Reference…
阅读更多...
【Docker】Docker操作容器命令

【Docker】Docker操作容器命令

1、容器 1.1简介 容器镜像是一个软件的轻量级独立可执行软件包&#xff0c;包含运行它所需的一切&#xff1a;代码&#xff0c;运行时&#xff0c;系统工具&#xff0c;系统库&#xff0c;设置。不管环境如何&#xff0c;集装箱化软件都可以运行相同的Linux和Windows应用程序…
阅读更多...
华为某员工爆料：偷偷跑出去面试，被面试官鄙视了。第一句话就问：华为淘汰的吧，35岁了，这个年龄在华为能混得下去吗？身体没啥毛病吧

华为某员工爆料：偷偷跑出去面试，被面试官鄙视了。第一句话就问：华为淘汰的吧，35岁了，这个年龄在华为能混得下去吗？身体没啥毛病吧

“你都35岁了&#xff0c;难不成是被华为淘汰的&#xff1f;在华为混不下去了吧&#xff1f;身体没啥毛病吧&#xff0c;我们这体检可是很严的。” 近日&#xff0c;一位华为员工在朋友圈爆料&#xff0c;自己在面试时遭到了面试官的无理取闹和人身攻击&#xff0c;原因仅仅是因…
阅读更多...
C语言中操作符详解（二）

C语言中操作符详解（二）

OK&#xff0c;今天继续为诸君带来有关C语言中操作符的讲解 一 . 位操作符 C语言中的位操作符我相信大家并不陌生&#xff0c;我们在之前就已经接触过了一些 位操作符&#xff08;位操作符的操作数只能是整数&#xff09;&#xff1a; &#xff08;1&#xff09;& &…
阅读更多...
头歌——机器学习——集成学习案例

头歌——机器学习——集成学习案例

第1关&#xff1a;基于集成学习模型的应用案例 任务描述 本次任务我们将会使用银行营销数据集&#xff08;来源于UCI数据集&#xff1a;UCI Machine Learning Repository &#xff09;,该数据集共45211条数据&#xff0c;涉及葡萄牙银行机构的营销活动&#xff0c;通过一些与…
阅读更多...
idea http client GET 请求 报503错误

idea http client GET 请求 报503错误

idea 提供的 http client 插件&#xff0c;在 GET 请求时总是 报503 的错误&#xff0c;但请求URL可以在浏览器中正常访问。 GET localhost:8080/student Response file saved. > 2024-06-20T160906.503.html 有一种原因跟本地配置的代理有关&#xff0c;如下图。如果在…
阅读更多...
ubuntu22.04笔记： 更换为阿里源

ubuntu22.04笔记： 更换为阿里源

没有按照LTS 版本 会遇到下面问题&#xff1a; 参考&#xff1a;https://zhuanlan.zhihu.com/p/691625646 Ubuntu 22.04代号为&#xff1a;jammy Ubuntu 20.04代号为&#xff1a;focal Ubuntu 19.04代号为&#xff1a;disco Ubuntu 18.04代号为&#xff1a;bionic Ubuntu …
阅读更多...
winmail添加gmail和QQ邮箱（现已更新为outlook mail）

winmail添加gmail和QQ邮箱（现已更新为outlook mail）

想在windows自带的邮件桌面应用里&#xff0c;不仅能访问outlook邮件&#xff0c;也能访问gmail邮件和QQ邮件的方法。 参考文章&#xff1a; Windows 10 的邮件怎么添加并同步 Gmail&#xff1f;​www.zhihu.com/question/53079836/answer/147669935?utm_psn178781450843941…
阅读更多...
嘉楠勘智CanMV-K230的大小核如何操作

嘉楠勘智CanMV-K230的大小核如何操作

摘要&#xff1a;嘉楠勘智CanMV-K230的帮助文档、例子模型说明中&#xff0c;一直在提“大核&#xff0c;小核”&#xff0c;还提到将文件复制到小核并解压&#xff0c;然后在大核中操作&#xff0c;本文介绍一下这两个“核”如何操作。 所需的硬件&#xff1a;CanMV-K230-V1.1…
阅读更多...
zkWASM：ZK+zkVM的下一站？

zkWASM：ZK+zkVM的下一站？

1. 引言 ZK技术具备极大通用性&#xff0c;也帮助以太坊从去中心化投资走向去信任化的价值观。“Don’t trust, Verify it!”&#xff0c;是ZK技术的最佳实践。ZK技术能够重构链桥、预言机、链上查询、链下计算、虚拟机等等一系列应用场景&#xff0c;而通用型的ZK协处理器就是…
阅读更多...
论坛实现随机发帖的学习

论坛实现随机发帖的学习

1、badboy操作&#xff0c;录制发帖全过程&#xff0c;录制结果保存&#xff0c;生成为.jmx格式的文件 2、在Jmeter中打开该.jmx文件&#xff0c;重命名&#xff0c;便于了解步骤 3、生成结果树&#xff0c;查看所以步骤是否正确 4、实现随机发帖。。。。还没写完
阅读更多...
Python爬虫-贝壳新房

Python爬虫-贝壳新房

前言 本文是该专栏的第32篇，后面会持续分享python爬虫干货知识，记得关注。 本文以某房网为例，如下图所示，采集对应城市的新房房源数据。具体实现思路和详细逻辑，笔者将在正文结合完整代码进行详细介绍。接下来，跟着笔者直接往下看正文详细内容。（附带完整代码） 正文 地…
阅读更多...
折线统计图 初级

折线统计图 初级

此为折线统计图的初级题目。 本次的题目较难&#xff0c;菜鸡请退出。 4. 下图显示了甲、乙两台电脑的价格以及它们已使用的年数&#xff0c;从图中可以知道( )。 15. 妈妈去菜市场买菜&#xff0c;走到半路遇到一位熟人聊了一会儿&#xff0c;突然发现忘了带钱。于是马上回…
阅读更多...
在 IntelliJ IDEA 中使用 Java 和 Selenium 模拟 Chrome 浏览器教程

在 IntelliJ IDEA 中使用 Java 和 Selenium 模拟 Chrome 浏览器教程

在 IntelliJ IDEA 中使用 Java 和 Selenium 模拟 Chrome 浏览器教程 1. 前言2. 环境准备3. 关闭谷歌自动更新通过服务禁用更新服务通过任务计划程序禁用更新任务 4. 项目添加 Maven 依赖项5. 编写自动化脚本6. 项目运行效果7. 代码示例8.常用方法示例页面请求定位标签获取内容操…
阅读更多...
26.3 Django路由层

26.3 Django路由层

1. 路由作用 在Django中, URL配置(通常称为URLconf)是定义网站结构的基础, 它充当着Django所支撑网站的目录. URLconf是一个映射表, 用于将URL模式(patterns)映射到Python的视图函数或类视图上. 这种映射机制是Django处理HTTP请求的基础, 它决定了当客户端发送请求时, Django如…
阅读更多...
LeetCode 算法：二叉树的最大深度 c++

LeetCode 算法：二叉树的最大深度 c++

原题链接&#x1f517;&#xff1a;二叉树的最大深度 难度&#xff1a;简单⭐️ 题目 给定一个二叉树 root &#xff0c;返回其最大深度。 二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。 示例 1&#xff1a; 输入&#xff1a;root [3,9,20,null,…
阅读更多...
最新文章

Copyright @ 2022~2023