蓝桥杯——18

学习视频：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##
*/

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

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

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

相关文章

《经典论文阅读2》基于随机游走的节点表示学习—Deepwalk算法

《经典论文阅读2》基于随机游走的节点表示学习—Deepwalk算法

word2vec使用语言天生具备序列这一特性训练得到词语的向量表示。而在图结构上&#xff0c;则存在无法序列的难题&#xff0c;因为图结构它不具备序列特性&#xff0c;就无法得到图节点的表示。deepwalk 的作者提出&#xff1a;可以使用在图上随机游走的方式得到一串序列&#x…
阅读更多...
Java 设计模式系列：模板方法模式

Java 设计模式系列：模板方法模式

简介 模板方法模式是一种行为型设计模式&#xff0c;它定义一个操作中的算法骨架&#xff0c;将一些步骤推迟到子类中。模板方法模式使得子类可以不改变一个算法的结构&#xff0c;即可重定义该算法的某些特定步骤。 在模板方法模式中&#xff0c;抽象类中定义了一系列基本操…
阅读更多...
网络篇10 | 网络层 IP

网络篇10 | 网络层 IP

网络篇10 | 网络层 IP 01 简介02 名称解释03 IP报文格式(IPv4)1&#xff09;4位版本协议(version)2&#xff09;4位首部长度(header length)3&#xff09;8位服务类型(Type Of Service, TOS)4&#xff09;16位总长度5&#xff09;16位(分片)标识6&#xff09;3位(分片)标志7&am…
阅读更多...
深度学习学习日记4.14 数据增强 Unet网络部分

深度学习学习日记4.14 数据增强 Unet网络部分

数据增强 transforms.Compose([&#xff1a;这表示创建一个转换组合&#xff0c;将多个数据转换操作串联在一起 transforms.RandomHorizontalFlip()&#xff1a;这个操作是随机水平翻转图像&#xff0c;以增加数据的多样性。它以一定的概率随机地水平翻转输入的图像。 transfo…
阅读更多...
coreldraw2024直装版下载 永久免费使用附下载安装教程（ 仅限 win10用户 ）

coreldraw2024直装版下载 永久免费使用附下载安装教程（ 仅限 win10用户 ）

CorelDRAW 2024具有一些特别的优势&#xff0c;这些优势不仅体现在其丰富的功能和卓越的性能上&#xff0c;还体现在其跨平台的兼容性上。 首先&#xff0c;CorelDRAW 2024支持多种操作系统平台&#xff0c;包括但不限于Windows 10和Windows 11等高级操作系统。这意味着无论是…
阅读更多...
webpack-(plugin，本地服务器，路径别名，安装vue)

webpack-(plugin，本地服务器，路径别名，安装vue)

安装vue npm i vue-loader -D npm i vue 编写一个vue文件&#xff1a; 在index.html中设置 一个id为app的div 将vue文件挂载到app中 vue比较特殊&#xff0c;除了使用loader外&#xff0c;还使用了plugin const path require("path"); const { VueLoaderPlugin …
阅读更多...
zabbix 使用 dataease 做数据大屏

zabbix 使用 dataease 做数据大屏

1、环境介绍 操作系统&#xff1a;龙蜥os 7.9 软件&#xff1a;dataease v1.18.18 zabbix&#xff1a; 6.0 2、软件下载 https://community.fit2cloud.com/#/products/dataease/downloads 3、将软件包上传到服务器并解压缩 tar -xvf dataease-v1.18.18-offline.tar.gz4、修改…
阅读更多...
鸿蒙端云一体化开发--开发云函数--适合小白体制

鸿蒙端云一体化开发--开发云函数--适合小白体制

开发云函数 那什么是云函数&#xff1f;我们将来又怎么去使用这个云函数呢&#xff1f; 答&#xff1a;我们之前要编写一些服务端的业务逻辑代码&#xff0c;那现在&#xff0c;在这种端云一体化的开发模式下&#xff0c;我们是把服务端的业务逻辑代码&#xff0c;通过云函数来…
阅读更多...
Mybatis中SqlSession接口中的selectList方法

Mybatis中SqlSession接口中的selectList方法

1、SqlSession SqlSession是Mybatis持久层框架提供的接口&#xff0c;该接口中包含了大量的CRUD操作方法&#xff08;既增删改查方法&#xff09;。 2、selectList方法 selectList方法是用于查询的方法&#xff0c;该方法具有多态性&#xff0c;如图所示&#xff08;打开myb…
阅读更多...
qemu源码解析一

qemu源码解析一

基于qemu9.0.0 简介 QEMU是一个开源的虚拟化软件&#xff0c;它能够模拟各种硬件设备&#xff0c;支持多种虚拟化技术&#xff0c;如TCG、Xen、KVM等 TCG 是 QEMU 中的一个组件&#xff0c;它可以将高级语言编写的代码&#xff08;例如 C 代码&#xff09;转换为可在虚拟机中…
阅读更多...
51单片机-独立按键模块

51单片机-独立按键模块

1. 独立按键控制LED状态 轻触按键实现原理&#xff1a;按下时&#xff0c;接通&#xff0c;通过金属弹片受力弹动来实现接通和断开。 松开按键 按下之后&#xff1a;就会被连接 同时按下K1和K2时&#xff0c;P2_0,接口所连LED灯才亮。 #include <REGX52.H> void ma…
阅读更多...
python-numpy(3)-线性代数

python-numpy(3)-线性代数

一、方程求解 参考资料 对于Ax b 这种方程&#xff1a; np.linalg.inv(A).dot(B)np.linalg.solve(A,b) 1.1 求解多元一次方程一个直观的例子 # AXB # X A^(-1)*B A np.array([[7, 3, 0, 1], [0, 1, 0, -1], [1, 0, 6, -3], [1, 1, -1, -1]]) B np.array([8, 6, -3, 1]…
阅读更多...
Vue - 6（ 13000 字 Vue3 入门级教程）

Vue - 6（ 13000 字 Vue3 入门级教程）

一 &#xff1a;Vue3 1.1 Vue3简介 2020年9月18日&#xff0c;Vue.js发布3.0版本&#xff0c;代号&#xff1a;One Piece&#xff08;海贼王&#xff09;耗时2年多、2600次提交、30个RFC、600次PR、99位贡献者github上的tags地址&#xff1a;https://github.com/vuejs/vue-ne…
阅读更多...
Android ParcelFileDescriptor实现进程间通信

Android ParcelFileDescriptor实现进程间通信

需求 一个通信通道&#xff0c;实现跨进程的的Socket网络通信。 具体的通信通道的图如下。 需求分析 我们需要一个进程一直做通信通道的事情&#xff0c;业务进程把数据通过进程间通信交给通信进程。通信进程通过Socket通道将数据发给网络另外一端的通信进程。接收端的通信进…
阅读更多...
RedisTemplate

RedisTemplate

3.3.RedisTemplate 在Sentinel集群监管下的Redis主从集群&#xff0c;其节点会因为自动故障转移而发生变化&#xff0c;Redis的客户端必须感知这种变化&#xff0c;及时更新连接信息。Spring的RedisTemplate底层利用lettuce实现了节点的感知和自动切换。 下面&#xff0c;我们…
阅读更多...
家庭网络防御系统搭建-虚拟机安装siem/securityonion网络连接问题汇总

家庭网络防御系统搭建-虚拟机安装siem/securityonion网络连接问题汇总

由于我是在虚拟机中安装的security onion&#xff0c;在此过程中&#xff0c;遇到很多的网络访问不通的问题&#xff0c;通过该文章把网络连接问题做一下梳理。如果直接把securityonion 安装在物理机上&#xff0c;网络问题则会少很多。 NAT无法访问虚拟机 security onion虚拟…
阅读更多...
ssm051网上医院预约挂号系统+jsp

ssm051网上医院预约挂号系统+jsp

网上医院预约挂号系统设计与实现 摘 要 如今的信息时代&#xff0c;对信息的共享性&#xff0c;信息的流通性有着较高要求&#xff0c;因此传统管理方式就不适合。为了让医院预约挂号信息的管理模式进行升级&#xff0c;也为了更好的维护医院预约挂号信息&#xff0c;网上医院…
阅读更多...
dbeaver数据库语言编辑器设置jdbc驱动

dbeaver数据库语言编辑器设置jdbc驱动

打开 dbeaver 软件 数据库 -> 驱动管理器 以mysql为例 双击 MySQL -> 库 -> 添加工件 然后 打开maven组件库 官网 找到mysql驱动对应的maven工件地址 复制进去然后确认就行了 参考 大神博客
阅读更多...
＜计算机网络自顶向下＞ TCPUDP套接字编程

＜计算机网络自顶向下＞ TCPUDP套接字编程

应用实现&#xff1a;源端的应用进程交换报文实现应用协议&#xff0c;来实现各种各样的网络应用&#xff08;dash&#xff0c;email, etc&#xff09; 而应用层通信不可以直接通信&#xff0c;需要借助下层的服务才可以进行&#xff0c;通过层间接口交给下层&#xff0c;通过…
阅读更多...
Hadoop概述及集群搭建

Hadoop概述及集群搭建

文章目录 一、Hadoop介绍二、Hadoop发展简史三、Hadoop核心组件四、Hadoop架构变迁1、Hadoop 1.02、Hadoop 2.03、Hadoop 3.0 五、Hadoop集群简介六、Hadoop部署模式七、Hadoop 集群搭建第一步&#xff1a;创建虚拟机第二步&#xff1a;安装Linux镜像第三步&#xff1a;网络配置…
阅读更多...
最新文章

Copyright @ 2022~2023