Level3题目整理

news2025/1/19 11:04:13

文章目录

    • L3-001 凑零钱
    • L3-002 特殊堆栈
    • L3-003 社交集群（并查集+vector+暴力⭐）
    • L3-004 肿瘤诊断(三维bfs)
    • L3-005 垃圾箱分布（多次dijkstra）
    • L3-008 喊山（邻接表+bfs🔺）
    • L3-010 是否完全二叉搜索树（不用建树判断是否满足，并输出层序遍历序列⭐⭐⭐）

L3-001 凑零钱

在这里插入图片描述
按从大到小排序，可以实现大的覆盖小的

#include<bits/stdc++.h>
using namespace std;
queue<int> q;
const int N = 1e4 + 10;
int n,m;
int v[N];
int dp[N];
//bool vis[N][110];
pair<int, int> pre[N][110];
bool cmp(int a,int b) {
	return a > b;
}

int main() {
	cin >> n >> m;
	for(int i = 1; i <= n; i++) {
		cin >> v[i];
	}

	sort(v + 1, v + 1 + n,cmp);

	for(int i = 1; i <= n; i++) {
		for(int j = m; j >= v[i]; j--) {
//			dp[j] = max(dp[j],dp[j - v[i]] + v[i]);
			if(dp[j] <= dp[j-v[i]] + v[i]) {
				dp[j] = dp[j-v[i]] + v[i];
				pre[i][j] = make_pair(i-1, j-v[i]);
//				vis[i][j] = true;
			} else {
				pre[i][j] = make_pair(i-1, j);
			}

		}
	}

	if(dp[m] == m) {
		pair<int, int> p = make_pair(n, m);
		while (p.first != 0) {
			int x = pre[p.first][p.second].first;
			int y = pre[p.first][p.second].second;
			if (y != p.second) {
				if (p.second != m) cout << ' ';
				cout << v[p.first];
			}
			p = make_pair(x, y);
		}
	} else {
		cout << "No Solution";
	}
}

暴力解法：（👍👍👍）
也可以过很多，先排个序，优先全选最小的，所以只要存在第一种方案即是最优的

#include<bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
int n,m;
int v[N];
int path[N];
int idx;
bool vis[N];
bool ok = false;
void dfs(int u,int sum) {
	
	if(u > n || sum > m) {
		return;
	}
	if(sum == m) {
		ok = true;
		int ct = 0;
		for(int i = 1; i <= n; i++) {

			if(vis[i]) {
				if(ct != 0) {
					cout << " ";
				}
				cout << v[i];
				ct++;
			}
		}

		exit(0);
	}
	
	vis[u] = true;
	dfs(u + 1,sum + v[u]);
	vis[u] = false;
	dfs(u + 1,sum);

}
int main() {
	cin >> n >> m;
	for(int i = 1; i <= n; i++) {
		cin >> v[i];
	}
	sort(v+1,v+1+n);
	dfs(0,0);
	
	cout << "No Solution";
	
}

L3-002 特殊堆栈

在这里插入图片描述
在这里插入图片描述
法一：暴力模拟过程（会TLE）

需要注意在peekMedian时，进行排序时，我们不能对进行模拟的数组直接进行排序，这样排序后会影响后续操作，我们应该再开一个辅助数组进行进行排序和输出。

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int st[N];
int cst[N];
int idx;
int main() {
	int n;
	cin >> n;
	for(int i = 1; i <= n; i++) {
		string op;
		int x;
		cin >> op;
		if(op == "Pop") {
			if(idx <= 0) {
				cout << "Invalid" << endl;
			} else {
				cout << st[idx] << endl;
                --idx;
			}
		} else if(op == "Push") {
			cin >> x;
			st[++idx] = x;
		} else {
			if(idx == 0) {
				cout << "Invalid" << endl;
			} else {
                for(int i = 1; i <= idx; i++){
                    cst[i] = st[i];
                }
				sort(cst+1,cst+1+idx);
				if(idx % 2 == 0){
					cout << cst[idx/2] << endl;
				}else{
					cout << cst[idx/2 + 1] << endl;
				}
			}
		}
	}
}

法二：采用vector顺序插入，lower_bound(),

#include<bits/stdc++.h>
using namespace std;
vector<int> num ;
stack<int> st ;
vector<int>::iterator it;
int main() {
	int n;
	cin >> n;
	for(int i = 1; i <= n; i++) {
		string op;
		int x;
		cin >> op;
		if(op == "Pop") {
			if(num.size() == 0) {
				cout << "Invalid" << endl;
			} else {
				cout << st.top() << endl;
				it = lower_bound(num.begin(),num.end(),st.top());
				num.erase(it);
				st.pop();
			}
		} else if(op == "Push") {
			
			cin >> x;
			it = lower_bound(num.begin(),num.end(),x);
			num.insert(it,x);
			st.push(x);
		} else {
			if(num.size() == 0) {
				cout << "Invalid" << endl;
			} else {
				int t = 0;
				if(num.size()%2 == 0) {
					t = num.size()/2;
				} else {
					t = (num.size() + 1) / 2;
				}
				cout << num[t - 1] << endl;
			}
		}
	}
}

L3-003 社交集群（并查集+vector+暴力⭐）

在这里插入图片描述

对于每个有相同爱好的人我们进行merge，并维护每一个集合的大小，对于判断两个人是否有相同爱好，我们暴力就可以过，最后对于每个集合，将集合大小存入multiset,进行从大到小排序即可

#include<bits/stdc++.h>
using namespace std;
vector<int> a[1100];
int n;
int fa[1100];
int sz[1100];
multiset<int,greater<int> > st;
multiset<int>::iterator it;
void init() {
	for(int i = 1; i <= 1000; i++) {
		fa[i] = i;
		sz[i] = 1;
	}
}
bool judge(int x,int y) {
	for(int i = 0; i < a[x].size(); i++) {
		for(int j = 0; j < a[y].size(); j++) {
			if(a[x][i] == a[y][j]) {
				return true;
			}
		}
	}
	return false;
}

int find(int x) {
	if(fa[x] == x) {
		return x;
	}
	return fa[x] = find(fa[x]);
}

void merge(int u,int v) {
	int fu = find(u);
	int fv = find(v);
	if(fu != fv) {
		fa[fu] = fv;
		sz[fv] += sz[fu];
	}
}
int main() {
	cin >> n;
	init();
	for(int i = 1; i <= n; i++) {
		int k;
		cin >> k;
		getchar();
		for(int j = 1; j <= k; j++) {
			int x;
			cin >> x;
			a[i].push_back(x);
		}
	}

	for(int i = 1; i <= n; i ++) {
		for(int j = i; j <= n; j++) {
			if(judge(i,j)) {
				merge(i,j);
			}
		}
	}
	
	for(int i = 1; i <= n; i++){
		if(fa[i] == i){
//			cout << sz[i] << " ";
			st.insert(sz[i]); 
		}
	}
	cout << st.size() << endl;
	for(it = st.begin(); it != st.end(); it++){
		if(it != st.begin()){
			cout << " ";
		}
		cout << *it;
	}
	
	
}

L3-004 肿瘤诊断(三维bfs)

在这里插入图片描述

在这里插入图片描述
法1：dfs(有两个点过不了，估计是递归太深)

#include<bits/stdc++.h>
using namespace std;
int idx;
int dx[6] = {0,0,-1,1,0,0};
int dy[6] = {-1,1,0,0,0,0};
int dz[6] = {0,0,0,0,-1,1};

int a[80][1300][150];
bool vis[80][1300][150];

int ans;
int cnt;
int m,n,l,t;
bool check(int z,int x,int y) {
	if(x >= 1 && x <= m && y >= 1 && y <= n && z >= 1 && z <= l && a[z][x][y] == 1 && !vis[z][x][y]){
		return true;
	}
	return false;
}
void dfs(int z,int x,int y) {
	for(int k = 0; k <= 5; k++) {
		int nx = x + dx[k];
		int ny = y + dy[k];
		int nz = z + dz[k];
		if(check(nz,nx,ny)) {
			cnt++;
			vis[nz][nx][ny] = true;
			dfs(nz,nx,ny);
		}
	}
}

int main() {
	cin >> m >> n >> l >> t;
	for(int z = 1; z <= l; z++) {
		for(int x = 1; x <= m; x++) {
			for(int y = 1; y <= n; y++) {
				cin >> a[z][x][y];
			}
		}
	}

	for(int z = 1; z <= l; z++) {
		for(int x = 1; x <= m; x++) {
			for(int y = 1; y <= n; y++) {
				if(!vis[z][x][y] && a[z][x][y] == 1) {
					cnt = 1;
					vis[z][x][y] = true;
					dfs(z,x,y);
					if(cnt >= t)
						ans += cnt;
				}
			}
		}
	}

	cout << ans;
}

法2：三维bfs

#include<bits/stdc++.h>
using namespace std;
int idx;
int dx[6] = {0,0,-1,1,0,0};
int dy[6] = {-1,1,0,0,0,0};
int dz[6] = {0,0,0,0,-1,1};

int a[80][1300][150];
bool vis[80][1300][150];

int ans;
int cnt;
int m,n,l,t;
struct node {
	int z,x,y;
};
queue<node> q;
bool check(int z,int x,int y) {
	if(x >= 1 && x <= m && y >= 1 && y <= n && z >= 1 && z <= l && a[z][x][y] == 1 && !vis[z][x][y]) {
		return true;
	}
	return false;
}
void bfs(int z,int x,int y) {
	node t = {z,x,y};
	q.push(t);
	while(!q.empty()) {
		
		node cur = q.front();
		int z = cur.z;
		int x = cur.x;
		int y = cur.y;
		q.pop();
		cnt++;
		
		for(int k = 0; k <= 5; k++) {
			int nx = x + dx[k];
			int ny = y + dy[k];
			int nz = z + dz[k];
			if(check(nz,nx,ny)) {
				vis[nz][nx][ny] = true;
				node temp = {nz,nx,ny};
				q.push(temp);
			}
		}
	}

}

int main() {
	cin >> m >> n >> l >> t;
	for(int z = 1; z <= l; z++) {
		for(int x = 1; x <= m; x++) {
			for(int y = 1; y <= n; y++) {
				cin >> a[z][x][y];
			}
		}
	}

	for(int z = 1; z <= l; z++) {
		for(int x = 1; x <= m; x++) {
			for(int y = 1; y <= n; y++) {
				if(!vis[z][x][y] && a[z][x][y] == 1) {
					cnt = 0;
					vis[z][x][y] = 1;
					bfs(z,x,y);
					if(cnt >= t)
						ans += cnt;
				}
			}
		}
	}

	cout << ans;
}

L3-005 垃圾箱分布（多次dijkstra）

在这里插入图片描述

思路：以垃圾桶为源点分别进行dijkstra，存下来可行的答案，排序输出即可
需要处理：因为垃圾桶为G1-Gm所以我们将垃圾桶映射到n+1到n+m即可
（1）需要注意每次选取的最小值应该是!vis[i]
（2）每次都需要进行初始化

坐标映射：

int isP(string x) {
	int index;
	if(x[0] == 'G') {
		index = n +  stoi(x.substr(1));
	} else {
		index = stoi(x);
	}
	return index;
}

#include<bits/stdc++.h>

using namespace std;
const int N = 1e3 + 200;
const int Inf = 1e9;
int a[N][N];
bool vis[N];
int dis[N];
int n,m,k,ds;

struct node {
	int id;
	double minn;
	double ave;
} p[N];

bool cmp(node a,node b) {
	if(a.minn == b.minn) {
		if(fabs(a.ave - b.ave) <= 1e-8) {
			return a.id < b.id;
		} else {
			return a.ave < b.ave;
		}
	}else{
		return a.minn > b.minn;
	}

}
int idx;
void dijkstra(int s) {
	for(int i = 1; i <= m + n; i++) {
		vis[i] = false;
		dis[i] = Inf;
	}

	dis[s] = 0;

	for(int i = 1; i <= m + n; i++) {

		int mini = -1;
		int minn = Inf;

		for(int j = 1; j <= m + n; j++) {
			if(!vis[j] && dis[j] < minn) {
				minn = dis[j];
				mini = j;
			}
		}

		if(mini == -1) {
			break;
		}
		vis[mini] = true;

		for(int j = 1; j <= m + n; j++) {
			if(!vis[j] && dis[j] > dis[mini] + a[mini][j]) {
				dis[j] = dis[mini] + a[mini][j];
			}
		}
	}


	int midis = Inf;
	bool ok = true;
	double sum = 0;

	for(int i = 1; i <= n; i++) {
//		cout << dis[i] << endl;
		midis = min(midis,dis[i]);

		if(dis[i] > ds) {
			ok = false;
			break;
		}
		sum += dis[i];
	}

	if(ok) {
		p[++idx] = {s - n,midis,sum/n};
	}

}

void init() {
	for(int i = 1; i < N; i++) {
		for(int j = 1; j < N; j++) {
			if(i != j) {
				a[i][j] = Inf;
			}
		}
	}
}

int isP(string x) {
	int index;
	if(x[0] == 'G') {
		index = n +  stoi(x.substr(1));
	} else {
		index = stoi(x);
	}
	return index;
}

void read() {
	string p1,p2;
	int dist;
	cin >> p1 >> p2 >> dist;
	int x = isP(p1);
	int y = isP(p2);
	a[x][y] = a[y][x] = dist;
}
int main() {
	cin >> n >> m >> k >> ds;

	init();
	for(int i = 1; i <= k; i++) {
		read();
	}

	for(int i = n + 1; i <= n + m; i++) {
		dijkstra(i);
	}
	if(idx == 0) {
		cout << "No Solution";
	} else {
		sort(p + 1,p + 1 + idx,cmp);

		cout << "G" << p[1].id << endl;
		printf("%.1f %.1f",p[1].minn,p[1].ave);
	}

}

L3-008 喊山（邻接表+bfs🔺）

在这里插入图片描述

在这里插入图片描述
刚开始想着用dfs，发现有两个点过不了，
在这里插入图片描述
由上图可以直到，dfs是深度优先，我们会觉得5是最远的，其实4和5是一样远的，但是答案要输出编号更小的，所以正确答案为4，很明显本题能看出来传递是一层一层的，所以这种问题用bfs更好，第一次找到某点一定是路径最短的，所以我们采用bfs进行查找，需要注意每次标记，特别是标记起始那个点，要不会死循环。

#include<bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
int h[N];
int ne[4*N];
int to[4*N];
int n,m,k;
int idx;
bool vis[N];

struct node {
	int id;
	int dis;
} a[N];
int cnt;
queue<node> q;

bool cmp(node o1,node o2) {
	if(o1.dis == o2.dis) {
		return o1.id < o2.id;
	} else {
		return o1.dis >  o2.dis;
	}
}

//void dfs(int u,int dep,int pre){
//
//	for(int i = h[u]; i != 0; i = ne[i]){
//		int j = to[i];
//		if(!vis[j]){
//			vis[j] = true;
//			a[cnt++] = {j,dep + 1};
//			dfs(j,dep + 1,u);
//			vis[j] = false;
//		}
//	}
//}

void bfs(int u) {
	vis[u] = true;
	node aa = {u,0};
	q.push(aa);
	
	while(!q.empty()) {
//		cout << q.size();
		node t = q.front();
		q.pop();
		int uu = t.id;
		for(int i = h[uu];i != 0 ; i = ne[i]) {
			int j = to[i];
//			cout << j;
			if(!vis[j]) {
				vis[j] = true;
				q.push({j,t.dis + 1});
				node cur = {j,t.dis + 1};
				a[cnt++] = cur;
			}
		}
	}
//	cout << endl;
}

void add(int u,int v) {
	ne[++idx] = h[u];
	to[idx] = v;
	h[u] = idx;
}
void init() {
	cnt = 0;
	for(int i = 0; i < N; i++) {
		vis[i] = false;
	}
}
int main() {
	cin >> n >> m >> k;
	for(int i = 1; i <= m; i++) {
		int x,y;
		cin >> x >> y;
		add(x,y);
		add(y,x);
	}
	for(int i = 1; i <= k; i++) {
		int x;
		cin >> x;
		init();
		cnt = 0;
//		dfs(x,0,-1);
		bfs(x);
		if(cnt == 0) {
			cout << "0" << endl;
		} else {
			sort(a,a + cnt,cmp);
			cout << a[0].id << endl;
		}

	}
}

L3-010 是否完全二叉搜索树（不用建树判断是否满足，并输出层序遍历序列⭐⭐⭐）

在这里插入图片描述
借鉴大佬的博客
太简洁了，

首先根据规则建树，并且在建树的过程中，我们就可以直到是不是完全二叉树，只要满足最大节点编号等于结点数就可以做到是完全二叉树（需要注意的是：N个点顺序插入空的树，说明第一个插入的点就是根节点，不需要自己去调整）

#include<bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
int t[100];
int n;
int root;
int maxn = 1;
void insert(int x) {
	int id = 1;
	while(t[id] != 0) {
		if(x > t[id]) {
			id = id * 2;
		} else {
			id = id * 2 + 1;
		}
	}
	t[id] = x;
	maxn = max(maxn,id);
}

int main() {
	cin >> n;
	cin >> root;
	t[1] = root;
	for(int i = 2; i <= n; i++) {
		int x;
		cin >> x;
		insert(x);
	}
	if(maxn == n) {
		cout << root;
		for(int i = 2; i <= maxn; i++) {
			if(t[i] != 0) {
				cout << " " << t[i];
			}
		}
		cout << endl << "YES";
	} else {
		cout << root;
		for(int i = 2; i <= maxn; i++) {
			if(t[i] != 0) {
				cout << " " << t[i];
			}
		}
		cout << endl << "NO";
	}
}

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

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

相关文章

C++ STL学习之【list的模拟实现】

C++ STL学习之【list的模拟实现】

✨个人主页&#xff1a; 夜 默 &#x1f389;所属专栏&#xff1a; C修行之路 &#x1f38a;每篇一句&#xff1a; 图片来源 A year from now you may wish you had started today. 明年今日&#xff0c;你会希望此时此刻的自己已经开始行动了。 文章目录&#x1f307;前言&am…
阅读更多...
零售数据分析之操作篇12：子查询的应用

零售数据分析之操作篇12：子查询的应用

各位数据的朋友&#xff0c;大家好&#xff0c;我是老周道数据&#xff0c;和你一起&#xff0c;用常人思维数据分析&#xff0c;通过数据讲故事。 上期内容与作业 上一讲讲了占比相关内存计算的应用场景&#xff0c;包括占比、TOP占比、累计占比等&#xff0c;不同的占比&am…
阅读更多...
sinGAN论文笔记

sinGAN论文笔记

Background Knowledge 基于推理的视觉理论&#xff1a; 只根据图像数据本省不能对相对应的物体空间结构提供充分的约束&#xff0c;也就是说这是一个约束不充分的问题&#xff0c;因此为了理解图像的内容必须要有附加的约束条件&#xff08;例如知道图中是哪一类物体的知识&am…
阅读更多...
帮助中心能帮助企业解决什么问题？

帮助中心能帮助企业解决什么问题？

帮助中心是企业在网站、应用程序或其他数字渠道上提供的一种资源&#xff0c;旨在帮助客户解决问题、回答常见问题并提供支持。一个完善的帮助中心可以为企业带来很多好处&#xff0c;包括提高客户忠诚度、提高满意度、降低客户支持成本等。 帮助中心能帮助企业解决的问题 提…
阅读更多...
为什么会有JMM？从0到1一次性说清楚

为什么会有JMM？从0到1一次性说清楚

JMM&#xff08;Java Memory Model&#xff09;是一种规范&#xff0c;定义了在多线程环境下Java程序中的内存访问行为。JMM保证了在多线程环境下程序的正确性&#xff0c;同时也允许编译器和处理器对指令进行优化&#xff0c;以提高程序的性能。 Java线程之间的通信由Java内存…
阅读更多...
网络编程套接字（一）

网络编程套接字（一）

学习任务&#xff1a; 我们先来认识端口号&#xff0c;区分好主机IP和端口号的区别&#xff0c;以及涉及到进程PID和端口号的区别。 然后简单认识一下TCP协议和UDP协议&#xff0c;这两个协议都是传输层的。接着了解什么是网络字节序&#xff0c;它有什么作用。然后是网络编程的…
阅读更多...
Windows搭建Typecho个人博客并发布公网访问【内网穿透】

Windows搭建Typecho个人博客并发布公网访问【内网穿透】

文章目录前言1. 环境安装2. 安装Typecho3. 安装cpolar内网穿透4. 固定公网地址5. 配置Typecho前言 本文小新为大家带来windwos系统搭建typecho博客cpolar内网穿透工具将博客发布到公共网络环境教程。 Typecho是一款PHP语言编写的开源博客程序&#xff0c;它是一个轻量级的内容…
阅读更多...
某某客户的一次勒索病毒应急响应

某某客户的一次勒索病毒应急响应

Lockbit勒索病毒应急响应背景1、应急处理排查2、勒索病毒来源分析3、勒索病毒分析4、勒索病毒解密5、主机分析分析6、后续安全加固和改进措施结论背景 美好的周六刚开始&#xff0c;眼睛一睁&#xff0c;领导就发消息&#xff0c;说某客户中了勒索病毒&#xff0c;特别着急&am…
阅读更多...
测评了100款零售软件，选出5个最好用零售软件分享给你！

测评了100款零售软件，选出5个最好用零售软件分享给你！

满大街的各种服装店、便利店、百货店、母婴店...... 每天都要处理大量的订单&#xff0c;使用传统的人工开单记账&#xff0c;效率低下、客户体验差、而且容易出现&#xff0c;需要耗费很多时间来回对账&#xff1b; 聪明的零售店老板都已经开始使用零售软件来管理门店&#xf…
阅读更多...
[C++]list类的模拟实现和相关函数的详解（正反向迭代器）

[C++]list类的模拟实现和相关函数的详解（正反向迭代器）

文章目录架构代码实现listNode正向迭代器框架迭代器函数重载*&#xff08;解引用&#xff09;->&#xff08;箭头指向&#xff09; -- ! 反向迭代器框架*&#xff08;解引用&#xff09;->&#xff08;箭头指向&#xff09; -- ! list默认成员函数构造函数拷贝构造赋值重…
阅读更多...
QT学习笔记2

QT学习笔记2

1.重载自定义信号与槽&#xff1a; 定义天黑类&#xff1a;里面有一个有参数的信号和没有参数的信号 tianhei.h #ifndef TIANHEI_H #define TIANHEI_H#include <QObject>class Tianhei : public QObject {Q_OBJECT public:Tianhei(); //构造函数声明signals:void tia…
阅读更多...
Linux 用户的特殊shell与PAM模块

Linux 用户的特殊shell与PAM模块

文章目录Linux 用户的特殊shell与PAM模块特殊的shell&#xff1a;/sbin/nologinPAM模块简介PAM模块设置语法常用模块简介login的PAM验证机制流程其他相关文件limits.conf使用案例/var/log/secure、/var/log/messagesLinux 用户的特殊shell与PAM模块 你想过吗&#xff1f;如果我…
阅读更多...
无向连通图中长度为 n 的循环

无向连通图中长度为 n 的循环

给定一个无向连通图和一个数字 n，计算图中长度为 n 的循环总数。长度为 n 的圈简单地表示该圈包含 n 个顶点和 n 条边。我们必须计算所有存在的此类循环。 示例： 输入：n = 4 输出：总周期数 = 3 解释 ：遵循 3 个独特的循环0 -> 1 -> 2 -> 3 -> 0 0 -> 1 …
阅读更多...
【一起啃书】《机器学习》第一章 绪论 + 第二章 模型评估与选择

【一起啃书】《机器学习》第一章 绪论 + 第二章 模型评估与选择

第一章 绪论 1.机器学习&#xff1a;研究如何通过计算的手段&#xff0c;利用经验来改善系统自身的性能。在计算机系统中&#xff0c;”经验“通常以“数据”的形式存在&#xff0c;所以机器学习研究的主要内容也是如何通过这些数据产生一个模型&#xff0c;进而通过这个模型为…
阅读更多...
基于SpringBoot+Vue毕业生信息招聘平台系统【源码+论文+演示视频+包运行成功】

基于SpringBoot+Vue毕业生信息招聘平台系统【源码+论文+演示视频+包运行成功】

您好&#xff0c;我是码农飞哥&#xff0c;感谢您阅读本文&#xff0c;欢迎一键三连哦。 &#x1f4aa;&#x1f3fb; 1. Python基础专栏&#xff0c;基础知识一网打尽&#xff0c;9.9元买不了吃亏&#xff0c;买不了上当。 Python从入门到精通 ❤️ 2.网上优质的Python题库很少…
阅读更多...
Hello之CJavaPython

Hello之CJavaPython

​ 前言&#xff0c;原来是java程序员&#xff0c;最近学习了一段时间发现&#xff0c;java只关注业务逻辑的开发&#xff0c;封装了很多的东西&#xff0c;导致底层的许多东西不是太了解&#xff0c;突然某一天&#xff0c;灵光凸现&#xff0c;既然语言都是相通的&#xff0c…
阅读更多...
工业机器人远程监控解决方案

工业机器人远程监控解决方案

一、项目背景 随着我国科技不断进步发展和产业升级的不断进行&#xff0c;现阶段机器人应用在生产制造行业以及运输行业已经变得越来越广泛。工业机器人机构复杂、维护成本高&#xff0c;机器人应用的这一行业现状&#xff0c;对工业机器人生产企业的产品高品质服务能力提出了…
阅读更多...
Samba共享

Samba共享

关闭selinux跟防火墙 setenforce 0 systemctl stop firewalld 安装samba以及客户端 yum install samba samba-client -y 创建共享目录 mkdir -p /data/share1 mkdir -p /data/public 添加samba用户并配置权限 useradd zsuser smbpasswd -a zsuser 修改配置文件并重启服…
阅读更多...
linux线程调度策略

linux线程调度策略

系统中既有分时调度&#xff0c;又有时间片轮转调度和先进先出调度 学习这个主要为了在linux多线程中&#xff0c;解决几条指令间延时在1-2ms内&#xff1b; 1.比如之前处理过&#xff1a;给一个板子发送一个can指令&#xff0c;接着需要给另外一个模块发送移动指令&#xff0c…
阅读更多...
ESP32设备驱动-CCS811数字气体空气质量传感器驱动

ESP32设备驱动-CCS811数字气体空气质量传感器驱动

CCS811数字气体空气质量传感器驱动 文章目录 CCS811数字气体空气质量传感器驱动1、CCS811介绍2、硬件准备3、软件准备4、驱动实现1、CCS811介绍 CCS811 是一种低功耗数字气体传感器解决方案，它集成了用于检测通常在室内发现的低水平 VOC 的气体传感器解决方案、微控制器单元 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023