蓝桥杯——18

news2024/9/25 1:16:32

学习视频：21-广度优先搜索练习_哔哩哔哩_bilibili

Q：密码锁

#include<iostream>
#include<queue>
using namespace std;
int s, e;
bool vis[10000];
struct node {
	int state;
	int step;
	node(int s1, int s2) {
		state = s1;
		step = s2;
	}
};
int bfs(int state, int step) {
	node now = node(state, step);
	queue<node> q;
	q.push(now);
	vis[now.state] = true;
	if (now.state == e) {
		return now.step;
	}
	//!!要标记状态后放进去
	while (!q.empty()) {
		now = q.front();
		q.pop();
		if (now.state == e) {
			return now.step;
		}
		//+1、-1、交换
		int a = now.state;
		int tmp;
		if (a % 10 == 9) {
			tmp = a / 10 * 10 + 1;
			if (!vis[tmp]) {
				vis[tmp] = true;
				q.push(node(tmp, now.step + 1));
			}
		}
		else {
			if (!vis[a + 1]) {
				vis[a + 1] = true;
				q.push(node(a + 1, now.step + 1));
			}
			
		}
		if (a % 100 / 10 == 9) {
			tmp = a / 100 * 100 + 10 + a % 10;
			if (!vis[tmp]) {
				q.push(node(tmp, now.step + 1));
				vis[tmp] = true;
			}
		}
		else {
			if (!vis[a + 10]) {
				vis[a + 10] = true;
				q.push(node(a + 10, now.step + 1));
			}
		}
		if (a % 1000 / 100 == 9) {
			tmp = a / 1000 * 1000 + 100 + a % 100;
			if (!vis[tmp]) {
				vis[tmp] = true;
				q.push(node(tmp, now.step + 1));
			}
		}
		else {
			if (!vis[a + 100]) {
				vis[a + 100] = true;
				q.push(node(a + 100, now.step + 1));
			}
		}
		if (a / 1000 == 9) {
			tmp = 1000 + a % 1000;
			if (!vis[tmp]) {
				vis[tmp] = true;
				q.push(node(tmp, now.step + 1));
			}
		}
		else {
			if (!vis[a + 1000]) {
				vis[1000 + a] = true;
				q.push(node(a + 1000, now.step + 1));
			}
		}
		//-
		if (a % 10 == 1) {
			if (!vis[a + 8]) {
				vis[a + 8] = 1;
				q.push(node(a + 8, now.step + 1));
			}
		}
		else {
			if (!vis[a - 1]) {
				vis[a - 1] = 1;
				q.push(node(a - 1, now.step + 1));
			}
		}
		if (a % 100 / 10 == 1) {
			if (!vis[a + 80]) {
				vis[a + 80] = 1;
				q.push(node(a + 80, now.step + 1));
			}
		}
		else {
			if (!vis[a - 10]) {
				vis[a - 10] = 1;
				q.push(node(a - 10, now.step + 1));
			}
		}
		if (a % 1000 / 100 == 1) {
			if (!vis[a + 800]) {
				vis[a + 800] = 1;
				q.push(node(a + 800, now.step + 1));
			}
		}
		else {
			if (!vis[a - 100]) {
				vis[a - 100] = 1;
				q.push(node(a - 100, now.step + 1));
			}
		}
		if (a / 1000 == 1) {
			if (!vis[a + 8000]) {
				vis[a + 8000] = 1;
				q.push(node(8000 + a, now.step + 1));
			}
		}
		else {
			if (!vis[a - 1000]) {
				vis[a - 1000] = 1;
				q.push(node(a - 1000, now.step + 1));
			}
		}
		// 
		// 交换
		int r1, r2, r3, r4;
		r1 = a % 10;
		r2 = a / 10 % 10;
		r3 = a / 100 % 10;
		r4 = a / 1000;
		q.push(node(1000 * r4 + r3 * 100 + r1 * 10 + r2, now.step + 1));
		q.push(node(1000 * r4 + r2 * 100 + r3 * 10 + r1, now.step + 1)); 
		q.push(node(1000 * r3 + r4 * 100 + r2 * 10 + r1, now.step + 1));	
	}	
}
int main() {
	cin >> s >> e;
	cout << bfs(s, 0);

	return 0;
}

Q：乳草的侵占

#include<iostream>
#include<queue>
using namespace std;
int X, Y, MX, MY;
char grace[105 ][105];
bool vis[105][105];
int dir[8][2] = { {0,1},{0,-1},{1,0},{-1,0},{1,1},{-1,-1},{1,-1},{-1,1} };
bool in(int x, int y) {
	return x >= 0 && x < Y && y >= 0 && y < X;
}
struct node {
	int x;
	int y;
	int day;
	node(int xx, int yy,int dd) {
		x = xx;
		y = yy;
		day = dd;
	}
};
int bfs(int x,int y) {
	queue<node> q;
	int ans = 0;
	node now = node(x, y, 0);
	q.push(now);
	vis[x][y] = true;
	while (!q.empty()){
		node a = q.front();
		q.pop();
		for (int i = 0; i < 8; i++) {
			int fx = a.x + dir[i][0];
			int fy = a.y + dir[i][1];
			if (!vis[fx][fy] && grace[fx][fy] != '*' && in(fx, fy)) {
				vis[fx][fy] == true;
				grace[fx][fy] = '*';
				q.push(node(fx, fy, a.day + 1));
				ans = a.day + 1;
			}
		}
	}

	return ans;
}
int main() {
	cin >> X >> Y >> MX >> MY;
	MY = Y - MY;
	MX = MX - 1;
	for (int i = 0; i < Y; i++) {
		cin >> grace[i];
	}
	cout << bfs(MY, MX);
	return 0;
}
/*
4 3 1 1
....
..*.
.**.
*/

Q：一维跳棋

好难，不会

#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
const int N = (1 << 20) * 21 + 5;
bool vis[1<<20][100];
struct node {
	int s, x;
};
int p[N];

int main() {
	int n;
	cin >> n;
	vector<node> a;
	queue<int> q;
	int s1 = (1 << n) - 1;  //999 B全在右边
	int s2 = s1 << n;  //999000 B全在左边（终止情况）
	q.push(a.size());      //q放的是状态的下标，a记录的是实际的状态
	vis[s1][n] = true;  //初始空的位置在n的位置
	a.push_back({ s1, n });
	while (!q.empty()) {
		int id = q.front();
		q.pop();
		int s = a[id].s, x = a[id].x;
		if (s == s2 && x == n) {  //成功了
			vector<int> ans;
			for (int i = id; i; i = p[i]) {
				ans.push_back(2 * n - a[i].x + 1);
			}
			reverse(ans.begin(), ans.end());
			for (int i = 0; i < ans.size(); i++) {
				char ch = i % 5 == 4 ? 'n' : ' ';
				cout << ans[i] << ch;
			}
			break;
		}
		//空格左边的棋子移到空格位置
		if (x < 2 * n) {
			int ts = s;
			int tx = x + 1;
			if (!vis[ts][tx]) {
				q.push(a.size());
				vis[ts][tx] = true; 
				p[a.size()] = id;
				a.push_back({ ts,tx });
			}
		}
		//空格右边的棋子移到空格位置
		if (x > 0) {
			int ts = s;
			int tx = x - 1;
			if (!vis[ts][tx]) {
				q.push(a.size());
				vis[ts][tx] = true; 
				p[a.size()] = id;
				a.push_back({ ts,tx });
			}
		}
		//空格左边棋子跳到空格
		if (x <= 2 * n - 2 && ((s >> x + 1 & 1) ^ (s >> x & 1))) {
			int ts = s ^ (3 << x);
			int tx = x + 2;
			if (!vis[ts][tx]) {
				q.push(a.size());
				vis[ts][tx] = true;
				p[a.size()] = id;
				a.push_back({ ts,tx });
			}
		}
		//空格右边棋子跳到空格
		if (x >= 2 && ((s >> x - 1 & 1) ^ (s >> x - 2 & 1))) {
			int ts = s ^ (3 << x - 2);
			int tx = x - 2;
			if (!vis[ts][tx]) {
				q.push(a.size());
				vis[ts][tx] = true;
				p[a.size()] = id;
				a.push_back({ ts,tx });
			}
		}
	}
	return 0;
}
/*
4 3 1 1
....
..*.
.**.
*/

放弃！！

Q：三阶平面魔方

#include<iostream>
#include<queue>
using namespace std;
bool vis[9876][54321] = {0};
int a[3];
struct node {
	int id = 0;
	int step = 0;
	node(int idd, int st) {
		id = idd;
		step = st;
	}
};
int num;
int main() {
	for (int i = 0; i < 3; i++) {
		cin >> a[i];
		num = a[i] + num * 1000;
	}
	queue<node> q;
	node now = node(num, 0);  //!!!怎么传参啊啊啊
	int aa = now.id;
	vis[aa / 100000][aa % 100000] = true;
	q.push(now);
	while (!q.empty()) {
		now = q.front();
		q.pop();
		if (now.id == 123456789) {
			cout<< now.step;
		}
		int hang1, hang2, hang3, hang, h;
		hang1 = now.id / 1000000;
		hang2 = now.id / 1000 % 1000;
		hang3 = now.id % 1000;
		//行变换右移
		hang = hang1 % 10 * 100 + hang1 / 100 * 10 + hang1 % 10 % 10;
		h = hang2 * 1000 + hang3 + 1000000 * hang;
		if (!vis[h / 100000][h % 100000]) {
			vis[h / 100000][h % 100000] = true;
			q.push(node(h, now.step + 1));
		}

		hang = hang2 % 10 * 100 + hang2 / 100 * 10 + hang2 % 10 % 10;
		h = hang * 1000 + hang3 + 1000000 * hang1;
		if (!vis[h / 100000][h % 100000]) {
			q.push(node(h, now.step + 1));
			vis[h / 100000][h % 100000] = 1;
		}

		hang = hang3 % 10 * 100 + hang3 / 100 * 10 + hang3 % 10 % 10;
		h = hang2 * 1000 + hang + 1000000 * hang1;
		if (!vis[h / 100000][h % 100000]) {
			q.push(node(h, now.step + 1));
			vis[h / 100000][h % 100000] = 1;
		}
		//行变换左移
		hang = hang1 % 10 * 10 + hang1 / 100 + hang1 % 10 % 10 * 100;
		h = hang2 * 1000 + hang3 + 1000000 * hang;
		if (!vis[h/100000][h%100000]) {
			q.push(node(h, now.step + 1));
			vis[h / 100000][h % 100000] = 1;
		}

		hang = hang2 % 10 * 10 + hang2 / 100 + hang2 % 10 % 10 * 100;
		h = hang * 1000 + hang3 + 1000000 * hang1;
		if (vis[h / 100000][h % 100000] == 0) {
			q.push(node(h, now.step + 1));
			vis[h / 100000][h % 100000] = 1;
		}

		hang = hang3 % 10 * 10 + hang3 / 100 + hang3 % 10 % 10 * 100;
		h = hang2 * 1000 + hang + 1000000 * hang1;
		if (vis[h / 100000][h % 100000] == 0) {
			q.push(node(h, now.step + 1));
			vis[h / 100000][h % 100000] = 1;
		}
		//列变换下移1
		int h1, h2, h3;
		h1 = hang1 - hang1 / 100 * 100 + hang3 / 100 * 100;
		h2 = hang2 - hang2 / 100 * 100 + hang1 / 100 * 100;
		h3 = hang3 - hang3 / 100 * 100 + hang2 / 100 * 100;
		h = h2 * 1000 + h3 + 1000000 * h1;
		if (vis[h / 100000][h % 100000] == 0) {
			q.push(node(h, now.step + 1));
			vis[h / 100000][h % 100000] = 1;
		}
		//列变换下移2
		h1 = hang1 - hang1 / 10 % 10 * 10 + hang3 / 10 % 10 * 10;
		h2 = hang2 - hang2 / 10 % 10 * 10 + hang1 / 10 % 10 * 10;
		h3 = hang3 - hang3 / 10 % 10 * 10 + hang2 / 10 % 10 * 10;
		h = h2 * 1000 + h3 + 1000000 * h1;
		if (vis[h / 100000][h % 100000] == 0) {
			q.push(node(h, now.step + 1));
			vis[h / 100000][h % 100000] = 1;
		}
		//列变换下移3
		h1 = hang1 - hang1 % 10 + hang3 % 10;
		h2 = hang2 - hang2 % 10 + hang1 % 10;
		h3 = hang3 - hang3 % 10 + hang2 % 10;
		h = h2 * 1000 + h3 + 1000000 * h1;
		if (vis[h / 100000][h % 100000] == 0) {
			q.push(node(h, now.step + 1));
			vis[h / 100000][h % 100000] = 1;
		}

		//列变换上移1
		h1 = hang1 - hang1 / 100 * 100 + hang2 / 100 * 100;
		h2 = hang2 - hang2 / 100 * 100 + hang3 / 100 * 100;
		h3 = hang3 - hang3 / 100 * 100 + hang1 / 100 * 100;
		h = h2 * 1000 + h3 + 1000000 * h1;
		if (vis[h / 100000][h % 100000] == 0) {
			q.push(node(h, now.step + 1));
			vis[h / 100000][h % 100000] = 1;
		}
		//列变换上移2
		h1 = hang1 - hang1 / 10 % 10 * 10 + hang2 / 10 % 10 * 10;
		h2 = hang2 - hang2 / 10 % 10 * 10 + hang3 / 10 % 10 * 10;
		h3 = hang3 - hang3 / 10 % 10 * 10 + hang1 / 10 % 10 * 10;
		h = h2 * 1000 + h3 + 1000000 * h1;
		if (vis[h / 100000][h % 100000] == 0) {
			q.push(node(h, now.step + 1));
			vis[h / 100000][h % 100000] = 1;
		}
		//列变换上移3
		h1 = hang1 - hang1 % 10 + hang2 % 10;
		h2 = hang2 - hang2 % 10 + hang3 % 10;
		h3 = hang3 - hang3 % 10 + hang1 % 10;
		h = h2 * 1000 + h3 + 1000000 * h1;
		
		if (vis[h / 100000][h % 100000] == 0) {
			q.push(node(h, now.step + 1));
			vis[h / 100000][h % 100000] = 1;
		}
	}
	//cout << bfs();
	return 0;
}
/*
412
756
389
*/

我的狗屎代码已经废了，不知道错在了哪里，不管了，放弃！！！

Q：吃糖的时间

#include<iostream>
#include<queue>
#include<vector>

using namespace std;
int n, p, c;
int m;
bool vis[10000];
int maxn;
struct child {
    int v;
    int step;
};
queue<child> q;

vector<int> vec[100010];
void bfs() {
    int i;
    child p, t;
    while (!q.empty()) {
        p = q.front();
        q.pop();
        for (int i = 0; i < vec[p.v].size(); i++) {
            t.v = vec[p.v][i];
            t.step = p.step + 1;
            if (!vis[t.v]) {
                q.push(t);
                vis[t.v] = 1;
                if (t.step > maxn) {
                    maxn = t.step;
                }
            }
        }
    }
}
int main() {
    cin >> n >> p >> c;
    cin >> m;
    int a, b;
    for (int i = 1; i <= p; i++) {
        cin >> a >> b;
        vec[a].push_back(b);
        vec[b].push_back(a);
    }
    child ch;
    ch.v = c;
    ch.step = 1;
    vis[ch.v] = 1;
    q.push(ch);
    bfs();
    cout << maxn + m;
    
    return 0;
}
/*
4 3 1
2
1 2
2 3
1 4
*/

又写了一次：

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
int n, r, c, m;
vector<int> vec[10001];
bool vis[10001];
struct node {
    int id;
    int time;
    node(int c,int tt) {
        time = tt;
        id = c;   //！！！写错了
    }
};
int t = 0;
int num = 0;
int main() {
    cin >> n >> r >> c >> m;
    int a, b;
    for (int i = 1; i <= r; i++) {  //！！！写错了
        cin >> a >> b;
        vec[a].push_back(b);
        vec[b].push_back(a);
    }
    queue<node> q;
    node now(c, 1);
    vis[c] = true;  //！！忘写了
    q.push(now);
    while (!q.empty()) {
        now = q.front();
        num++;
        q.pop();
        if (num == n) {
            cout << now.time + m;
            break;
        }
        for (int i = 0; i < vec[now.id].size(); i++) {   //！！越界了
            if (!vis[vec[now.id][i]]) {
                vis[vec[now.id][i]] = true;
                q.push(node(vec[now.id][i], now.time + 1));
            }
        }
    }
    return 0;
}
/*
4 3 1
2
1 2
2 3
1 4
*/

Q:蒜头军回家

#include<iostream>
#include<queue>
using namespace std;
int n, m;
char map[2000][2000];
bool vis[2000][2000][2];   //!!!取完钥匙剩下的路都可以走，要区分来时去时路
bool flag;
bool in(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m;
}
struct node {
    int x, y;
    int step;
    char ch;
    bool find = false;
    node(int xx, int yy, int c, int s, bool f) {
        x = xx;
        y = yy;
        step = s;
        ch = c; 
        find = f;
    }
    node(int xx, int yy, int c, int s) {
        x = xx;
        y = yy;
        step = s;
        ch = c;
    }
};
int dir[4][2] = { {1,0},{-1,0},{0,1},{0,-1} };
//先取了钥匙再回家
int main() {
    cin >> n >> m;
    int x, y;
    for (int i = 0; i < n; i++) {
        cin >> map[i];
        for (int j = 0; j < m; j++) {
            if (map[i][j] == 'S') {
                x = i;
                y = j;
            }
        }
    }
    queue<node> q;
    node now = node(x, y, map[x][y], 0);
    vis[x][y][0] = 1;  //!!!别忘了
    q.push(now);
    while (!q.empty()) {
        now = q.front();
        q.pop();
        if (now.find && now.ch == 'T') {
            cout << now.step << endl;
            break;
        }
        for (int i = 0; i < 4; i++) {
            int fx = now.x + dir[i][0];
            int fy = now.y + dir[i][1];

            if (!vis[fx][fy][now.find] && map[fx][fy] != '#' && in(fx, fy)) {
                if (map[fx][fy] == 'P') {
                    q.push(node(fx, fy, map[fx][fy], now.step + 1,true));
                    vis[fx][fy][now.find] = 1;
                }
                else {
                    vis[fx][fy][now.find] = 1;
                    q.push(node(fx, fy, map[fx][fy], now.step + 1, now.find));
                }
            }
        }

    }
    return 0;
}
/*
8 10
P.####.#P#
..#..#...#
..#T##.#.#
..........
..##.#####
..........
#####...##
###....S##
*/

后面是选做，不做了，因为有点难

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

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

相关文章

排序算法—堆排序

排序算法—堆排序

文章目录 堆排序堆思路过程建堆排序 代码实现 堆排序 时间复杂度&#xff1a;O(N*logN) 稳定性&#xff1a;不稳定&#xff08;相同元素排序后的相对位置改变&#xff09; 堆 堆的逻辑结构是一棵完全二叉树&#xff1b;堆的物理结构是一个数组&#xff0c;通过下标表示父子结…
阅读更多...
[计算机效率] 时间记录工具：ManicTime

[计算机效率] 时间记录工具：ManicTime

3.24 时间记录工具&#xff1a;ManicTime ManicTime是一款数据收集软件&#xff0c;主要用于记录电脑上各种软件使用所花费的时间以及电脑闲置的时间。用户还可以定制记录某一时间段内的系统活动。 数据收集&#xff1a;ManicTime能够静默运行于后台&#xff0c;自动跟踪并收…
阅读更多...
美易全球投资中心：金价暴涨背后，美债越来越没人要了？

美易全球投资中心：金价暴涨背后，美债越来越没人要了？

金价暴涨背后&#xff1a;天量发行的美债越来越没人要了&#xff1f; 近期&#xff0c;国际金价的大涨几乎吸引了全世界投资者的目光。而在狂热的金市买盘背后&#xff0c;而另一避险资产美国国债&#xff0c;则呈现了完全不同的一幕萧条场景。 一系列疲软的美国国债拍卖表现&…
阅读更多...
在线知识库如何从零开始搭建？这篇文章来教你！

在线知识库如何从零开始搭建？这篇文章来教你！

引言&#xff1a; 有没有想过把那些零散在脑海中的点点滴滴整理起来&#xff0c;建立一个属于自己的在线知识库&#xff1f;无论是个人学习&#xff0c;团队协作&#xff0c;还是企业管理&#xff0c;一个良好的知识库都能帮我们更高效地存储和分享知识。如果你还在为“怎么建知…
阅读更多...
创新营销利器：淘宝扭蛋机小程序开发全解析

创新营销利器：淘宝扭蛋机小程序开发全解析

在数字化浪潮的推动下&#xff0c;淘宝扭蛋机小程序的开发成为了一种全新的购物体验。它巧妙地将传统扭蛋机的乐趣与移动技术的便捷相结合&#xff0c;为用户带来了前所未有的惊喜与互动。 淘宝扭蛋机小程序的开发&#xff0c;不仅是一次技术的革新&#xff0c;更是一次购物方…
阅读更多...
基于Springboot+Vue的Java项目-高校心理教育辅导系统开发实战(附演示视频+源码+LW)

基于Springboot+Vue的Java项目-高校心理教育辅导系统开发实战(附演示视频+源码+LW)

大家好&#xff01;我是程序员一帆&#xff0c;感谢您阅读本文&#xff0c;欢迎一键三连哦。 &#x1f49e;当前专栏&#xff1a;Java毕业设计 精彩专栏推荐&#x1f447;&#x1f3fb;&#x1f447;&#x1f3fb;&#x1f447;&#x1f3fb; &#x1f380; Python毕业设计 &am…
阅读更多...
【C 数据结构】静态链表

【C 数据结构】静态链表

文章目录 【 1. 基本原理 】1.1 静态链表中的节点1.2 备用链表 【 2. 静态链表的创建 】2.1 实例1 - 创建静态链表&#xff0c;指定值2.2 实例2 - 创建静态链表&#xff0c;默认值 【 3. 静态链表 添加元素 】【 4. 静态链表 删除元素 】【 5. 静态链表 查找元素 】【 6. 静态链…
阅读更多...
模型预测控制MPC（2）—— 无约束线性MPC

模型预测控制MPC（2）—— 无约束线性MPC

前文&#xff1a;模型预测控制MPC&#xff08;1&#xff09;—— 基础概念参考&#xff1a;模型预测控制&#xff08;2022春&#xff09;本文从偏控制的角度介绍无约束线性MPC方法&#xff0c; x , u , J x,u,J x,u,J 分别代表状态、动作和代价函数 文章目录 1. 问题定义1.1 多…
阅读更多...
HCIP课后习题之一

HCIP课后习题之一

1、路由协议用工作机制上分为那几种&#xff1f;分别是&#xff1f; A&#xff1a;两种。分别是静态路由和动态路由&#xff08;可分为IGP和EGP&#xff09; 2、IGP和EGP协议有哪些&#xff1f; A&#xff1a;IGP: RIP、OSPF、ISIS、EIGRP EGP: BGP 3、路由优先级的用途&…
阅读更多...
反爬虫之代理IP封禁-协采云IP池

反爬虫之代理IP封禁-协采云IP池

反爬虫之代理IP封禁-协采云IP池 1、目标网址2、IP封禁4033、协采云IP池 1、目标网址 aHR0cDovL3d3dy5jY2dwLXRpYW5qaW4uZ292LmNuLw 2、IP封禁403 这个网站对IP的要求很高&#xff0c;短时间请求十几次就会遭关进小黑屋。如下图&#xff1a; 明显是网站进行了反爬处理&…
阅读更多...
FFmpeg: 自实现ijkplayer播放器--06封装打开和关闭stream

FFmpeg: 自实现ijkplayer播放器--06封装打开和关闭stream

文章目录 流程图stream openstream close流程图 stream open 初始化SDL以允许⾳频输出；初始化帧Frame队列初始化包Packet队列初始化时钟Clock初始化音量创建解复用读取线程read_thread创建视频刷新线程video_refresh_threadint FFPlayer::stream_open(const char
阅读更多...
Windows下安装GPU版Pytorch

Windows下安装GPU版Pytorch

升级Driver到最新版本 Windows搜索栏中输入设备管理器找到显示适配器一项&#xff0c;点击展开&#xff0c;你将看到你的NVIDIA显卡列在其中右键点击你的NVIDIA显卡&#xff0c;选择更新驱动软件…。在弹出的对话框中&#xff0c;选择自动搜索更新的驱动软件。之后&#xff0c…
阅读更多...
Scrapy框架 进阶

Scrapy框架 进阶

Scrapy框架基础Scrapy框架进阶 【五】持久化存储 命令行&#xff1a;json、csv等管道&#xff1a;什么数据类型都可以 【1】命令行简单存储 &#xff08;1&#xff09;语法 Json格式 scrapy crawl 自定义爬虫程序文件名 -o 文件名.jsonCSV格式 scrapy crawl 自定义爬虫程…
阅读更多...
二叉树的链式存储——补充

二叉树的链式存储——补充

/二叉树的结点&#xff08;链式存储) typedef struct BiTNode{ElemType data; //数据域struct BiTNode*lchild,*rchild //左、右孩子指针 }BiTNode,*BiTree;如下图进行存放&#xff1a; 所以&#xff0c;一个二叉树有n个结点的话&#xff0c;那总共就会有2n个指针域…
阅读更多...
怎么做预约小程序_探索我们的全新预约小程序

怎么做预约小程序_探索我们的全新预约小程序

在繁忙的现代生活中&#xff0c;无论是想预约一次美容护理&#xff0c;还是预定一家心仪的餐厅&#xff0c;亦或是安排一次专业的咨询服务&#xff0c;我们都希望能够在最短的时间内完成这些操作&#xff0c;节省时间和精力。如今&#xff0c;一款全新的预约小程序应运而生&…
阅读更多...
鸿蒙语言TypeScript学习第16天：【类】

鸿蒙语言TypeScript学习第16天：【类】

1、TypeScript 类 TypeScript 是面向对象的 JavaScript。 类描述了所创建的对象共同的属性和方法。 TypeScript 支持面向对象的所有特性&#xff0c;比如 类、接口等。 TypeScript 类定义方式如下&#xff1a; class class_name { // 类作用域 }定义类的关键字为 class&am…
阅读更多...
AI天使汇联合150家顶级基金、战投，征集优秀AI创业项目

AI天使汇联合150家顶级基金、战投，征集优秀AI创业项目

鉴于AI天使汇主办的2024年3月期优秀项目征集活动效果超出预期&#xff0c;3月活动最后TOP20路演者中已有多家快速拿到了TS。 路演活动质量受到了AI创业公司和基金/战投伙伴的高度评价&#xff0c;现在开始四月期活动报名! 本期征集活动联合的顶级基金和战投数量增加到了150家…
阅读更多...
MGRE-OSPF接口网络类型实验

MGRE-OSPF接口网络类型实验

OSPF接口网络类型实验 一&#xff0c;实验拓扑 初始拓扑&#xff1a; 最终拓扑&#xff1a; 二&#xff0c;实验要求及分析 要求&#xff1a; 1&#xff0c;R6为ISP只能配置IP地址&#xff0c;R1-R5的环回为私有网段 2&#xff0c;R1/R4/R5为全连的MGRE结构&#xff0c;R…
阅读更多...
儿童护眼台灯怎么选？五款必选的高口碑护眼台灯推荐

儿童护眼台灯怎么选？五款必选的高口碑护眼台灯推荐

儿童台灯&#xff0c;想必大家都不会陌生了&#xff0c;是一种学生频繁使用的小灯具&#xff0c;一般指放在桌面用的有底座的电灯。随着近年来儿童青少年的视力急速下滑&#xff0c;很多家长都会选择给孩子选择一款合适的护眼台灯&#xff0c;以便孩子夜晚学习能有个好的照明环…
阅读更多...
Stable Diffusion教程：LoRA模型

Stable Diffusion教程：LoRA模型

LoRA模型是一种微调模型&#xff0c;它不能独立生成图片&#xff0c;常常用作大模型的补充&#xff0c;用来生成某种特定主体或者风格的图片。 下载模型 在模型下载网站&#xff0c;如果模型是LoRA模型&#xff0c;网站会特别标识出来。以 liblib.ai为例&#xff1a; 模型左…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023