一本通 3.2.1 队列的基本应用

1332：【例2-1】周末舞会

【题目描述】

假设在周末舞会上，男士们和女士们进入舞厅时，各自排成一队。跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。规定每个舞曲能有一对跳舞者。若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。现要求写一个程序，模拟上述舞伴配对问题。

【题目分析】

使用两个队列，q1表示男q2表示女，定义两组队列指针 h1,h2,t1,t2
循环m次，先将男的入队，循环n次，将女的入队；
循环k次，将男女队列一起输出，再将男女队列队首元素分别计入相应队列队尾

【代码实现】

#include <bits/stdc++.h>

using namespace std;

int q1[10005], q2[10005];
int main() {
	//input data
	int m, n, k;
	cin >> m >> n >> k;
	int h1 = 1, t1 = 1;
	int h2 = 1, t2 = 1;
	for (int i = 1; i <= m; i++) {
		q1[t1++] = i;
	}
	for (int i = 1; i <= n; i++) {
		q2[t2++] = i;
	}

	for (int i = 1; i <= k; i++) {
		cout << q1[h1] << " " << q2[h2] << endl;
		q1[t1++] = q1[h1++];
		q2[t2++] = q2[h2++];
	}
	return 0;

}

1333：【例2-2】Blah数集

【题目描述】

大数学家高斯小时候偶然间发现一种有趣的自然数集合Blah，对于以a为基的集合Ba定义如下：

(1)a是集合Ba的基，且a是Ba的第一个元素；

(2)如果x在集合Ba中，则2x+1和3x+1也都在集合Ba中；

(3)没有其他元素在集合Ba中了。

现在小高斯想知道如果将集合Ba中元素按照升序排列，第N个元素会是多少？

【题目分析】

设定一个队列que[1000005]，使用tail指向队尾，h1指向2*x+1的起点数据，h2指向3*x+1的起点数据
初始化： tail=h1=h2=1;  que[tail++]=x
重复执行直到 tail>n 循环内部：如果2*que[h1]+1<que[h2]*3+1  que[tail++]=2*que[h1++]+1
                                                 如果2*que[h1]+1>que[h2]*3+1  que[tail++]=3*que[h2++]+1
                                                 如果2*que[h1]+1==que[h2]*3+1  h1++;
(两者相等时，可以将h2往后移，h1对应值进入队列，也可以将h1后移，在后面的循环中h2对应值进入队列)

【代码实现】

#include <bits/stdc++.h>

using namespace std;

int que[1000005];
int x, x1, x2, n;
int main() {
	//input data

	while (cin >> x >> n) {
		int h1 = 1, h2 = 1;
		int tail = 1;
		que[tail++] = x;
		while (tail <= n) {
			if (que[h1] * 2 + 1 < que[h2] * 3 + 1)
				que[tail++] = que[h1++] * 2 + 1;
			else if (que[h1] * 2 + 1 > que[h2] * 3 + 1)
				que[tail++] = que[h2++] * 3 + 1;
			else
				h1++;
		}
		cout << que[n] << endl;
	}

	return 0;
}

1334：【例2-3】围圈报数

【题目描述】

有ｎ个人依次围成一圈，从第１个人开始报数，数到第ｍ个人出列，然后从出列的下一个人开始报数，数到第ｍ个人又出列，…，如此反复到所有的人全部出列为止。设ｎ个人的编号分别为1，2，…，n，打印出列的顺序。

【题目分析】

问题本质：经典约瑟夫问题  解题思想：使用数组模拟链表进行模拟

解题过程：定义数组que[105]  数组下标i为人的编号，数组内容que[i]为编号为i的人的下一人的编号
方法1：j指向报数为1的人的上一人，循环执行j=que[j]并进行计数，直到计数为m时，que[j]为出队的人
           让j指向他的后面第二个人，跳过一人，que[j]=que[que[j]]
方法2：j指向报数为1的人，循环执行j=que[j]并进行计数，直到计数为m-1时，que[j]为出队的人
           让j指向他的后面第二个人，跳过一人，que[j]=que[que[j]]，j指向报数为1的人j=que[j]\

【代码实现】

	#include <bits/stdc++.h>
	
	using namespace std;
	
	int que[105];
	//第1个人指向第2个人  第2个人指向第3个人
	int main() {
		//input data
		int n, m;
		cin >> n >> m;
		//创建链表
		for (int i = 1; i <= n; i++) {
			que[i] = i + 1;
		}
		que[n] = 1;
		//需要出列n个人
		int j = n;
		for (int i = 1; i <= n; i++) {
			int count = 1;
			while (count < m ) {
				j = que[j];
				count++;
			}
			cout << que[j] << " ";
			que[j] = que[que[j]];
//			j = que[j];
		}
		return 0;
	}

1335：【例2-4】连通块

【题目描述】

一个n × m的方格图，一些格子被涂成了黑色，在方格图中被标为1，白色格子标为0。问有多少个四连通的黑色格子连通块。四连通的黑色格子连通块指的是一片由黑色格子组成的区域，其中的每个黑色格子能通过四连通的走法（上下左右），只走黑色格子，到达该联通块中的其它黑色格子。

【题目分析】

广度优先搜索

【代码实现】

#include <bits/stdc++.h>

using namespace std;

int n, m;
int a[105][105];
bool vis[105][105];
int _next[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1},};
void bfs(int x, int y) {
	pair<int, int> que[10005];
	int head = 1, tail = 1;
	que[tail++] = make_pair(x, y);
	while (head < tail) {
		x = que[head].first;
		y = que[head].second;
		for (int i = 0; i <= 3; i++) {
			int nx = x + _next[i][0];
			int ny = y + _next[i][1];
			if (nx < 1 || ny < 1 || nx > n || ny > m) continue;
			if (vis[nx][ny] || a[nx][ny] == 0) continue;
			vis[nx][ny] = 1;
			que[tail++] = make_pair(nx, ny);
		}
		head++;
	}
}
int main() {
	//input data
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			cin >> a[i][j];
		}
	}
	int ans = 0;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			if (a[i][j] == 1 && vis[i][j] == 0) {
				ans++;
				vis[i][j] = 1;
				bfs(i, j);  //广度优先搜索
			}
		}
	}
	cout << ans << endl;
	return 0;
}

1359：围成面积

【题目描述】

编程计算由“*”号围成的下列图形的面积。面积计算方法是统计*号所围成的闭合曲线中水平线和垂直线交点的数目。如下图所示，在10×10的二维数组中，有“*”围住了15个点，因此面积为15

【题目分析】

读取数据到10-*10的数组中，扩展为12*12外圈都为0，使用广度优先搜索记录封闭图形外面0的个数ans1

遍历所有数据，记录1的个数ans2，所以封闭0的面积为12*12-ans1-ans2

【代码实现】

#include <bits/stdc++.h>

using namespace std;

int n = 10;
int a[15][15];
bool vis[15][15];
int _next[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1},};
int main() {
	//input data
	int ans1 = 0, ans2 = 0;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			cin >> a[i][j];
			if (a[i][j] == 1) ans2++;
		}
	}
	//寻找外圈0的个数
	pair<int, int> que[10005];
	int head = 1, tail = 1;
	ans1++;
	vis[0][0] = 1;
	que[tail++] = make_pair(0, 0);
	while (head < tail) {
		int x = que[head].first;
		int y = que[head].second;
		for (int i = 0; i < 4; i++) {
			int nx = x + _next[i][0];
			int ny = y + _next[i][1];
			if (nx < 0 || ny < 0 || nx > n + 1 || ny > n + 1) continue;
			if (vis[nx][ny] == 1 || a[nx][ny] == 1) continue;
			vis[nx][ny] = 1;
			ans1++;
			que[tail++] = make_pair(nx, ny);
		}
		head++;
	}

	//包围0的数量为 11*11-ans1-ans2
//	cout << ans2 << endl;
	cout << (12 * 12 - ans1 - ans2) << endl;


	return 0;
}

1360：奇怪的电梯(lift)

【题目描述】

大楼的每一层楼都可以停电梯，而且第i层楼（1≤i≤N）上有一个数字Ki(0≤=Ki≤=N）。电梯只有四个按钮：开，关，上，下。上下的层数等于当前楼层上的那个数字。当然，如果不能满足要求，相应的按钮就会失灵。例如：3 3 1 2 5代表了Ki（K1=3,K2=3,……），从一楼开始。在一楼，按“上”可以到4楼，按“下”是不起作用的，因为没有−2−2楼。那么，从A楼到B楼至少要按几次按钮呢？

【题目分析】

问题本质：每一步有两种扩展选择的广度优先搜索

【代码实现】

#include <bits/stdc++.h>

using namespace std;

int n, a, b;
int k[205];
pair<int, int> que[40005];
int head = 1, tail = 1;
bool vis[205];
int main() {
	//input data
	cin >> n >> a >> b;
	for (int i = 1; i <= n; i++) {
		cin >> k[i];
	}
	int min_step = -1;
	//使用广搜解决问题
	que[tail++] = make_pair(a, 0);
	vis[a] = 1;
	while (head < tail) {
		if (que[head].first == b) {
			min_step = que[head].second;
			break;
		}
		int x = que[head].first;
		int step = que[head].second;
		int nx1 = x + k[x];
		if (nx1 >= 1 && nx1 <= n && vis[nx1] == 0) {
			vis[nx1] = 1;
			que[tail++] = make_pair(nx1, step + 1);
		}
		int nx2 = x - k[x];
		if (nx2 >= 1 && nx2 <= n && vis[nx2] == 0) {
			vis[nx2] = 1;
			que[tail++] = make_pair(nx2, step + 1);
		}
		head++;
	}
	cout << min_step;
	return 0;
}

1361：产生数(Produce)

【题目描述】

给出一个整数n（n≤2000）和k个变换规则（k≤15）。规则：

① 1个数字可以变换成另1个数字；

② 规则中，右边的数字不能为零。

例如：n=234，k=2规则为

2 → 5

3 → 6

上面的整数234经过变换后可能产生出的整数为（包括原数）234，534，264，564共4种不同的产生数。

求经过任意次的变换（0次或多次），能产生出多少个不同的整数。仅要求输出不同整数个数。

【题目分析】

方法1：对输入的整数n的每一位i按照规则进行广度优先搜索，确定数字的可能ans[i]
不同整数的个数为\prod_{i=1}^m ans[i]
方法2：对设定的规则采用邻接矩阵存储，使用floyed算法求0-9每两个数字的可连通性，
遍历每两个数字并计数ans[i]，不同整数的个数为\prod_{i=1}^m ans[i]

方法3：并查集  略

方法4：深搜 略

【代码实现】

并查集算法 

#include <bits/stdc++.h>

using namespace std;

int n, k;
struct node {
	int sum;
	int father;
} a[105];

int find_father(int i) {
	if (a[i].father == i) return  i;
	else return a[i].father = find_father(a[i].father);
}

int main() {
	//input data
	cin >> n >> k;
	//init
	for (int i = 1; i <= n; i++) {
		a[i].sum = 1;
		a[i].father = i;
	}

	//查找与合并
	for (int i = 1; i <= k; i++) {
		int x, y;
		cin >> x >> y;
		int x_father = find_father(x);
		int y_father = find_father(y);
		if (x_father != y_father) { //右边归顺左边
			a[y_father].father = x_father;
			a[x_father].sum += a[y_father].sum;
		}
	}
	//统计数据
	int ans = 0;
	int max_famely = 0;
	for (int i = 1; i <= n; i++) {
		if (a[i].father == i) {
			ans++;
			max_famely = max(max_famely, a[i].sum);
		}
	}
	//结果输出
	cout << ans << " " << max_famely << endl;

	return 0;
}

 广搜算法

#include <bits/stdc++.h>

using namespace std;

int rule[10][16];
int que[1005];
bool vis[10];
int head, tail;
int ans[10];

int main() {
	//input data
	int n, k;
	cin >> n >> k;
	for (int i = 1; i <= k; i++) {
		int x, y;
		cin >> x >> y;
		rule[x][++rule[x][0]] = y;
	}
	//0-9 bfs
	for (int i = 0; i <= 9; i++) {
		head = tail = 1;
		memset(vis, 0, sizeof(vis));
		que[tail] = i;
		tail++;
		vis[i] = 1;
		while (head != tail) {
			int num = que[head];
			head++;
			ans[i]++;
			for (int j = 1; j <= rule[num][0]; j++) {
				if (vis[rule[num][j]] == 0) {
					que[tail] = rule[num][j];
					tail++;
					vis[rule[num][j]] = 1;
				}
			}
		}
	}
	int maxans = 1;
	while (n != 0) {
		maxans *= ans[n % 10];
		n /= 10;
	}
	cout << maxans;
	return 0;
}

 floyed算法

#include <bits/stdc++.h>

using namespace std;

bool rule[10][10];
int ans[10];
int main() {
	//input data
	int n, k;
	cin >> n >> k;
	for (int i = 0; i <= 9; i++) {
		rule[i][i] = 1;
	}

	for (int i = 1; i <= k; i++) {
		int x, y;
		cin >> x >> y;
		rule[x][y] = 1;
	}
	
	//floyed
	for(int k=0;k<=9;k++){
		for(int i=0;i<=9;i++){
			for(int j=0;j<=9;j++){
				rule[i][j]=rule[i][j]||(rule[i][k]&&rule[k][j]);
			}
		}
	}
	
	//scan and update ans
	for(int i=0;i<=9;i++){
		for(int j=0;j<=9;j++){
			if(rule[i][j]) ans[i]++;
		}
	}
	int maxans = 1;
	while (n != 0) {
		maxans *= ans[n % 10];
		n /= 10;
	}
	cout << maxans;
	return 0;
}

1362：家庭问题(family)

【题目描述】

有n个人，编号为1,2,……n，另外还知道存在K个关系。一个关系的表达为二元组（α，β）形式，表示α，β为同一家庭的成员。

当n，k和k个关系给出之后，求出其中共有多少个家庭、最大的家庭中有多少人？

例如：n＝6，k＝3，三个关系为（1,2），(1,3)，(4,5)

此时，6个人组成三个家庭，即：｛1,2,3｝为一个家庭，｛4,5｝为一个家庭，｛6｝单独为一个家庭，第一个家庭的人数为最多。

【题目分析】

方法1：对每个家庭成员i的进行广度优先搜索，记录家庭成员人数a[i],如果家庭成员没有遍历过ans++,
最大的家庭成员数：max(a[i])  1<=i<=n ,家庭数为ans;


方法2：对每个家庭成员i进行并查集记录（父亲father和家族人数sum），如果两个人不是同一个father，右边y归顺左边x，
a[y_father].father=x_father, a[x_father].sum+=a[y_father].sum;  访问每个家庭成员i,如果a[i].father=i,说明是祖先，统计
祖先的个数即为家族的个数，统计祖先自带家族成员的个数最大值，即为最大家族的人数。


方法3：深搜 与广搜类似 略


方法4：连通性判断floyed算法，可以建立邻接矩阵，统计每个家庭成员i可以连通的成员数量最大值即为最大家族的人数，使用
标记数组访问每个i的连通性，如果存在连通ans++,标记i和i的连通 标记数组为1，否则继续进行遍历未被标记的i

【代码实现】

#include <bits/stdc++.h>

using namespace std;

int rule[105][105];
int que[105];
bool vis[105];
int head, tail;
int main() {
	//input data
	int n, k;
	cin >> n >> k;
	for (int i = 1; i <= k; i++) {
		int x, y;
		cin >> x >> y;
		rule[x][++rule[x][0]] = y;
		rule[y][++rule[y][0]] = x;
	}

	//Everyone bfs
	int family = 0;
	int maxans = 0;
	int ans = 0;
	for (int i = 1; i <= n; i++) {
		if (vis[i]) continue;
		ans = 0;
		family++;
		head = tail = 1;
		que[tail] = i, tail++;
		ans++;
		vis[i] = 1;
		while (head != tail) {
			int num = que[head];
			head++;
			for (int j = 1; j <= rule[num][0]; j++) {
				if (vis[rule[num][j]] == 0) {
					que[tail] = rule[num][j], tail++;
					vis[rule[num][j]] = 1;
					ans++;
				}
			}
		}
		maxans = max(maxans, ans);

	}
	cout << family << " " << maxans;
	return 0;
}
#include <bits/stdc++.h>

using namespace std;

int n, k;
struct node {
	int sum;
	int father;
} a[105];

int find_father(int i) {
	if (a[i].father == i) return  i;
	else return a[i].father = find_father(a[i].father);
}

int main() {
	//input data
	cin >> n >> k;
	//init
	for (int i = 1; i <= n; i++) {
		a[i].sum = 1;
		a[i].father = i;
	}

	//查找与合并
	for (int i = 1; i <= k; i++) {
		int x, y;
		cin >> x >> y;
		int x_father = find_father(x);
		int y_father = find_father(y);
		if (x_father != y_father) { //右边归顺左边
			a[y_father].father = x_father;
			a[x_father].sum += a[y_father].sum;
		}
	}
	//统计数据
	int ans = 0;
	int max_famely = 0;
	for (int i = 1; i <= n; i++) {
		if (a[i].father == i) {
			ans++;
			max_famely = max(max_famely, a[i].sum);
		}
	}
	//结果输出
	cout << ans << " " << max_famely << endl;

	return 0;
}

1418：猴子选大王

【题目描述】

由经典约瑟夫问题改成。

有N个猴子，编号从1到N。每个猴子对应一个正整数Xi,表示如果从编号为i的猴子开始报数，需要数到Xi。

这N个猴子围成一圈，从第一个开始报数，数到第1个猴子对应的正整数X1的猴子出队，然后从它的下一位继续从1开始报数，数到对应的Xi时出队，如此循环直到剩下一个猴子，最后剩下的那个猴子就是猴子们选出的大王。

例如：

N=5,Xi=5,对应为：1，2，3，4，5

出队的顺序为：1，3，4，5

【题目分析】

使用数组a[i]记录每个猴子的报数为1时，下次需要出列的数字k
报数出列的过程与经典约瑟夫问题相同，不同的是只要有人出列，就要更新k的数值
最后在循环外设置记录变量last1，在循环内满足出列人数为n时，记录下出列人的编号

【代码实现】

#include <bits/stdc++.h>

using namespace std;

int monkey[1000005];
int num[1000005];
int main() {
	//input data
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++) {
		monkey[i] = i + 1;
		cin >> num[i];
	}
	monkey[n] = 1;

	int k = 0;
	int p = n;
	int start = num[1];
	while (k < n - 1) {
		int say = 0;
		while (say < start - 1) {
			p = monkey[p];
			say++;
		}
		monkey[p] = monkey[monkey[p]];
		start = num[monkey[p]];
		k++;
	}
	cout << p << endl;
	return 0;
}

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

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

相关文章

【数据结构】树和二叉树的介绍

【数据结构】树和二叉树的介绍

文章目录前言一、树1.1 树的概念1.2 树的相关概念1.3 树的表示1.4 树的用途二、二叉树2.1 二叉树的概念2.2 两种特殊的二叉树2.3 二叉树的性质2.4 二叉树的存储方式总结前言 树是一种让程序员们既爱又恨的数据结构。它就像是一棵大树&#xff0c;让你可以轻松地摘取其中的果实…
阅读更多...
【10】核心易中期刊推荐——模式识别与机器学习

【10】核心易中期刊推荐——模式识别与机器学习

🚀🚀🚀NEW！！！核心易中期刊推荐栏目来啦 ~ 📚🍀 核心期刊在国内的应用范围非常广，核心期刊发表论文是国内很多作者晋升的硬性要求，并且在国内属于顶尖论文发表，具有很高的学术价值。在中文核心目录体系中，权威代表有CSSCI、CSCD和北大核心。其中，中文期刊的数…
阅读更多...
【C++进阶】C++11(中)左值引用和右值引用

【C++进阶】C++11(中)左值引用和右值引用

文章目录左值引用左值引用的概念左值引用的使用右值引用右值引用的概念右值引用的使用左右值相互引用左值引用对右值进行引用右值引用对左值进行引用右值引用使用场景和意义左值引用的优势左值引用的短板右值引用的优势完美转发模板万能引用完美转发实际运用场景左值引用 左值…
阅读更多...
vue3+ts 开发效率提升

vue3+ts 开发效率提升

1、vite pnpm项目初始化 pnpm&#xff1a; 比npm或yarn快10倍 pnpm与其他包管理器&#xff08;如npm和Yarn&#xff09;的不同之处在于它使用一种称为“硬链接”的独特安装方法。当你使用PNPM安装一个包时&#xff0c;它并不会将包的文件复制到每个项目的node_modules目录中&a…
阅读更多...
图形视图界面 图形效果

图形视图界面 图形效果

Qt的标准图形效果类&#xff1a; QGraphicsBlurEffect提供模糊效果QGraphicsColorizeEffect提供染色效果QGraphicsDropShadowEffect提供阴影效果QGraphicsOpacityEffect提供透明效果 QGraphicsBlurEffect&#xff08;模糊效果&#xff09; 模糊效果会模糊源。此效果对于减少细…
阅读更多...
VS Code工作区用法

VS Code工作区用法

背景VS Code可以通过"文件/打开文件夹"来打开本地项目&#xff0c;但是想要打开多个项目便需要来回切换&#xff0c;比较费劲。此时就可以使用工作区功能&#xff0c;将不同的项目放置到同一个工作区中&#xff0c;这样切换项目的时候就会非常方便。操作方法打开其中…
阅读更多...
免费搭建个人博客

免费搭建个人博客

免费搭建个人博客,并发布到公网 利用hexo搭建个人博客&#xff0c;通过gitee的pages发布到公网 1 前置准备 安装git、安装node.js&#xff08;尽量选择长期支持的版本) node.js官网&#xff1a;https://nodejs.org/en/ git官网&#xff1a;https://git-scm.com/book/zh/v2 安装…
阅读更多...
如何衡量你的Facebook广告活动的成功

如何衡量你的Facebook广告活动的成功

投入大量资金和资源在Facebook广告上并不总能带来预期的回报&#xff0c;这很可能是由于缺乏恰当的衡量广告活动成功的方法。在这篇文章中&#xff0c;我们将介绍一些关键的指标&#xff0c;帮助你更好地了解如何衡量你的Facebook广告活动的成功。1.费用每次点击&#xff08;CP…
阅读更多...
Spring和IDEA都不推荐用的@Autowired注解，为什么还有那么多人用？

Spring和IDEA都不推荐用的@Autowired注解，为什么还有那么多人用？

Autowired的默认装配 我们都知道在spring中Autowired注解&#xff0c;是用来自动装配对象的。通常&#xff0c;我们在项目中是这样用的&#xff1a; package com.sue.cache.service;import org.springframework.stereotype.Service;Service public class TestService1 {publ…
阅读更多...
你是否了解AR技术？AR技术就在我们身边

你是否了解AR技术？AR技术就在我们身边

文章目录专栏导读1、前言2、AR技术原理3、游戏领域应用4、教育领域应用5、医疗领域应用6、零售领域应用专栏导读 ✍ 作者简介&#xff1a;i阿极&#xff0c;CSDN Python领域新星创作者&#xff0c;专注于分享python领域知识。 ✍ 本文录入于《数据分析之道》&#xff0c;本专栏…
阅读更多...
C/C++每日一练(20230325)

C/C++每日一练(20230325)

目录 1. 搜索插入位置 &#x1f31f; 2. 结合两个字符串 &#x1f31f; 3. 同构字符串 &#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Golang每日一练 专栏 Python每日一练 专栏 C/C每日一练 专栏 Java每日一练 专栏 1. 搜索插入位置 给定一个排序数…
阅读更多...
CAN通信----电路图

CAN通信----电路图

CAN通信----基本原理 一、CAN总线网络连接 1.闭环总线网络----ISO11898 闭环总线网络高速、短距离&#xff0c;它的总线最大长度为 40m&#xff0c;通信速度最高为 1Mbps&#xff0c;总线的两端各要求有一个120 欧的电阻。 2.开环总线网络----ISO11519 开环总线网络低速、…
阅读更多...
LeetCode394.字符串解码

LeetCode394.字符串解码

LeetCode刷题记录 文章目录&#x1f4dc;题目描述&#x1f4a1;解题思路⌨C代码&#x1f4dc;题目描述 给定一个经过编码的字符串&#xff0c;返回它解码后的字符串。 编码规则为: k[encoded_string]&#xff0c;表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保…
阅读更多...
1652_MIT 6.828 shell例程重定向的实现分析

1652_MIT 6.828 shell例程重定向的实现分析

全部学习汇总&#xff1a; GreyZhang/g_unix: some basic learning about unix operating system. (github.com) 前面完成了一个单独命令执行之后&#xff0c;想放弃这个简单shell的实现。后来想想多少还是有几分不甘心&#xff0c;还是耐着心思把这个做完吧&#xff01; 这次&…
阅读更多...
基于pytorch+Resnet101加GPT搭建AI玩王者荣耀

基于pytorch+Resnet101加GPT搭建AI玩王者荣耀

本源码模型主要用了SamLynnEvans Transformer 的源码的解码部分。以及pytorch自带的预训练模型"resnet101-5d3b4d8f.pth"本资源整理自网络&#xff0c;源地址&#xff1a;https://github.com/FengQuanLi/ResnetGPT注意运行本代码需要注意以下几点 注意&#xff01;&a…
阅读更多...
多线程控制讲解与代码实现

多线程控制讲解与代码实现

多线程控制 回顾一下线程的概念 线程是CPU调度的基本单位&#xff0c;进程是承担分配系统资源的基本单位。linux在设计上并没有给线程专门设计数据结构&#xff0c;而是直接复用PCB的数据结构。每个新线程&#xff08;task_struct{}中有个指针都指向虚拟内存mm_struct结构&am…
阅读更多...
你真的掌握到“优先级队列“的精髓了吗？

你真的掌握到“优先级队列“的精髓了吗？

前文如果我们给每个元素都分配一个数字来标记其优先级&#xff0c;不妨设较小的数字具有较高的优先级&#xff0c;这样我们就可以在一个集合中访问优先级最高的元素并对其进行查找和删除操作了。这样&#xff0c;我们就引入了优先级队列 这种数据结构。一&#xff0c;priority_…
阅读更多...
QT/C++调试技巧：内存泄漏检测

QT/C++调试技巧：内存泄漏检测

文章目录内存泄漏方案一方案二&#xff1a;CRT调试定位代码位置方法1方法2其它问题方案三&#xff1a;使用vs诊断工具方案四&#xff1a;使用工具VLD&#xff08;Visio Leak Detector&#xff09;方案五Cppcheck内存泄漏 内存泄漏&#xff1a;指的是在程序里动态申请的内存在使…
阅读更多...
STM32学习（八）

STM32学习（八）

STM32串口与电脑USB口通信 特别注意&#xff1a;两个设备之间的TXD和RXD&#xff0c;必须交差连接&#xff0c;方可正常通信 RS-232异步通信协议 启动位&#xff1a;必须占1个位长&#xff0c;必须保持逻辑0电平。有效数据位&#xff1a;可选5、6、7、8、9个位长&#xff0c;L…
阅读更多...
【嵌入式烧录/刷写文件】-1-详解Motorola S-record(S19/SREC/mot/SX)格式文件

【嵌入式烧录/刷写文件】-1-详解Motorola S-record(S19/SREC/mot/SX)格式文件

目录 1 什么是Motorola S-record 2 Motorola S-record的格式 2.1 Motorola S-record的结构 2.1.1 “Record type记录类型”的说明 2.1.2 “Record length记录长度”的说明 2.1.3 如何计算“Checksum校验和” 2.2 Record order记录顺序 2.3 Text line terminator文本行终…
阅读更多...
最新文章

Copyright @ 2022~2023