一本通 2.8.1 广度优先搜索算法

news2024/11/18 11:44:55

1329：【例8.2】细胞

【题目描述】

一矩形阵列由数字0到9组成,数字1到9代表细胞,细胞的定义为沿细胞数字上下左右还是细胞数字则为同一细胞,求给定矩形阵列的细胞个数。如:阵列

有4个细胞。 

【题目分析】

遍历所有节点，当无标识且不为零，进行深度优先搜索
深搜函数创建队列，对每个满足要求的节点（没有超过边界，无标识，非零）的加入队列，并进行标识

【代码实现】

#include <bits/stdc++.h>

using namespace std;
int m, n;
int a[105][105];
int vis[105][105];
int _count = 0;
int _next[4][2] = {{0, -1}, {-1, 0}, {0, 1}, {1, 0}};
void bfs(int x, int y) {  //行是x 列是y
	queue<pair<int, int>>que;
	que.push(make_pair(x, y));
	vis[x][y] = 1;
	while (!que.empty()) {
		int px = que.front().first;
		int py = que.front().second;
		for (int i = 0; i < 4; i++) {
			int nx = px + _next[i][0];
			int ny = py + _next[i][1];
			if (nx >= 1 && nx <= m && ny >= 1 && ny <= n && vis[nx][ny] == 0 && a[nx][ny] > 0) {
				vis[nx][ny] = 1;
				que.push(make_pair(nx, ny));
			}
		}
		que.pop();
	}
}
int main() {
	//input data
	cin >> m >> n;
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= n; j++) {
			char ch;
			cin >> ch;
			a[i][j] = ch - '0';
		}
	}
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= n; j++) {
			if (vis[i][j] == 0 && a[i][j] > 0) {
				_count++;
				bfs(i, j);
			}
		}
	}
	cout << _count << endl;
	return 0;
}

1330：【例8.3】最少步数

【题目描述】

在各种棋中，棋子的走法总是一定的，如中国象棋中马走“日”。有一位小学生就想如果马能有两种走法将增加其趣味性，因此，他规定马既能按“日”走，也能如象一样走“田”字。他的同桌平时喜欢下围棋，知道这件事后觉得很有趣，就想试一试，在一个（100×100）的围棋盘上任选两点A、B，A点放上黑子，B点放上白子，代表两匹马。棋子可以按“日”字走，也可以按“田”字走，俩人一个走黑马，一个走白马。谁用最少的步数走到左上角坐标为(1,1)的点时，谁获胜。现在他请你帮忙，给你A、B两点的坐标，想知道两个位置到（1,1）点可能的最少步数。

【题目分析】

1、每一步有8+4=12种走法，使用结构体记录走的步数和点位，当前点的步数等于前一个点的步数+1
2、每一步判断有无标识，判断越界，从队列中取数的时候判断是否到达终点

【代码实现】

#include <bits/stdc++.h>

using namespace std;

int L;
struct node {
	int x;
	int y;
	int step;
	node() {};
	node(int _x, int _y, int _step): x(_x), y(_y), step(_step) {};
} p1;
int vis[305][305];
int _next[12][2] = { {1, 2}, {1, -2}, {2, 1}, {2, -1}, {-1, 2}, {-1, -2}, {-2, 1}, {-2, -1},
	{2, 2}, {2, -2}, {-2, 2}, {-2, -2}
};
void bfs() {
	memset(vis, 0, sizeof(vis));
	queue<node>que;
	que.push(p1);
	vis[p1.x][p1.y] = 1;
	while (!que.empty()) {
		int x = que.front().x;
		int y = que.front().y;
		int s = que.front().step;
		if (x == 1 && y == 1) {
			cout << s << endl;
			break;
		}
		for (int i = 0; i < 12; i++) {
			int nx = x + _next[i][0];
			int ny = y + _next[i][1];
			if (nx >= 1 && ny >= 1 && nx <= 100 && ny <= 100 && vis[nx][ny] == 0) {
				vis[nx][ny] = 1;
				que.push(node(nx, ny, s + 1));
			}
		}
		que.pop();
	}
}
int main() {
	//input data
	int x, y;
	cin >> x >> y;
	p1 = node(x, y, 0);
	bfs();
	cin >> x >> y;
	p1 = node(x, y, 0);
	bfs();
	return 0;
}

1248：Dungeon Master

【题目描述】

这题是一个三维的迷宫题目，其中用‘.’表示空地，‘#’表示障碍物，‘S’表示起点，‘E’表示终点，求从起点到终点的最小移动次数，解法和二维的类似，只是在行动时除了东南西北移动外还多了上下。可以上下左右前后移动，每次都只能移到相邻的空位，每次需要花费一分钟，求从起点到终点最少要多久。

【题目分析】

1、创建一个含有x,y,z,step的结构体记录过程点位，标识数组也为三维
2、读入数据，找到起点和终点p1和p2，并将终点设为"."，使用三维数组记录点位
3、将起点加入队列，每一步具有6个方向的移动，判断是否越界、是否已经标识，当前点的步数等于前一个点位步数+1
4、在出队的过程中判断是否到达终点，到达终点直接输出步数s

【代码实现】

#include <bits/stdc++.h>

using namespace std;
int ceng, chang, kuan;
int a[105][105][105];
struct node {
	int x, y, z;
	int step;
	node() {};
	node(int _z, int _y, int _x, int _step): x(_x), y(_y), z(_z), step(_step) {};
} p1, p2;
bool vis[105][105][105];
int _next[6][3] = {{0, -1, 0}, {-1, 0, 0}, {0, 1, 0}, {1, 0, 0}, {0, 0, 1}, {0, 0, -1}};
void bfs() {
	memset(vis, 0, sizeof(vis));
	queue<node> que;
	que.push(p1);
	vis[p1.x][p1.y][p1.z] = 1;
	bool flag = 1;
	while (!que.empty()) {
		int x = que.front().x;     //宽
		int y = que.front().y;     //长
		int z = que.front().z;     //层
		int s = que.front().step;
//		printf("(%d,%d,%d)\n",x,y,z);
		if (x == p2.x && y == p2.y && z == p2.z) {
			printf("Escaped in %d minute(s).\n", s);
			flag = 0;
			break;
		}
		for (int i = 0; i < 6; i++) {
			int nx = x + _next[i][0];
			int ny = y + _next[i][1];
			int nz = z + _next[i][2];
			if (nx < 1 || nx > kuan || ny < 1 || ny > chang || nz < 1 || nz > ceng)
				continue;
			if (vis[nx][ny][nz] == 1 || a[nz][ny][nx] == 1)
				continue;
			que.push(node(nz, ny, nx, s + 1));
			vis[nx][ny][nz] = 1;
		}
		que.pop();
	}
	if (flag)cout << "Trapped!" << endl;
}
int main() {
	char ch;
	//input data
	while (1) {
		cin >> ceng >> chang >> kuan;
		if (ceng == 0 && chang == 0 && kuan == 0) break;
		for (int i = 1; i <= ceng; i++) {		//输入层 长 宽
			for (int j = 1; j <= chang; j++) {
				string s;
				cin >> s;
				for (int k = 1; k <= kuan; k++) {
					ch = s[k - 1];
					if (ch == '.')a[i][j][k] = 0;  //i--层  j--长  k--宽
					if (ch == '#')a[i][j][k] = 1;
					if (ch == 'S')p1 = node(i, j, k, 0);  //层--z 长--y 宽--x
					if (ch == 'E') {
						p2 =   node(i, j, k, 0);
						a[i][j][k] = 0;
					}
				}
			}
		}
		bfs();
	}
	return 0;
}

1249：Lake Counting

【题目描述】

题意：有一块N×M的土地，雨后积起了水，有水标记为‘W’，干燥为‘.’。八连通的积水被认为是连接在一起的。请求出院子里共有多少水洼？

【题目分析】

遍历所有节点，当无标识且不为零，进行深度优先搜索
深搜函数创建队列，对每个满足要求的节点（没有超过边界，无标识，为W）的加入队列，并进行标识

【代码实现】

#include <bits/stdc++.h>

using namespace std;

int n, m;
bool a[115][115];
bool vis[115][115];
int _next[8][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
void bfs(int x, int y) {
	queue<pair<int, int>>que;
	que.push(make_pair(x, y));
	vis[x][y] = 1;
	while (!que.empty()) {
		int px = que.front().first;
		int py = que.front().second;
		for (int i = 0; i < 8; i++) {
			int nx = px + _next[i][0];
			int ny = py + _next[i][1];
			if (nx >= 1 && nx <= n && ny >= 1 && ny <= m && vis[nx][ny] == 0 && a[nx][ny] == 1) {
				vis[nx][ny] = 1;
				que.push(make_pair(nx, ny));
			}
		}
		que.pop();
	}
}
int main() {
	//input data
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			char ch;
			cin >> ch;
			if (ch == 'W') a[i][j] = 1;
			else        a[i][j] = 0;
		}
	}
	int _count = 0;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			if (vis[i][j] == 0 && a[i][j]) {
				_count++;
				bfs(i, j);
			}
		}
	}
	cout << _count << endl;
	return 0;
}

1250：The Castle

【题目描述】

 【题目分析】

 【代码实现】

#include <bits/stdc++.h>

using namespace std;

int m, n;
int a[55][55];
int vis[55][55];
int _count = 0, maxa = 0;
int _next[4][2] = {{0, -1}, //无西墙
                   {-1, 0}, //无北墙
				   {0, 1},  //无东墙
				   {1, 0}}; //无南墙
int bfs(int x, int y) {  //行是x 列是y
	int area = 0;
	queue<pair<int, int>>que;
	que.push(make_pair(x, y));
	vis[x][y] = 1;
	while (!que.empty()) {
		int px = que.front().first;
		int py = que.front().second;
		area++;
		int qi = a[px][py];
		for (int i = 0; i < 4; i++) {
			if (!((qi >> i) & 1)) {
				int nx = px + _next[i][0];
				int ny = py + _next[i][1];
				if (vis[nx][ny] == 0) {
					vis[nx][ny] = 1;
					que.push(make_pair(nx, ny));
				}
			}
		}
		que.pop();
	}
	return area;
}
int main() {
	//input data
	cin >> m >> n;
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= n; j++) {
			cin >> a[i][j];
		}
	}
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= n; j++) {
			if (vis[i][j] == 0) {
				_count++;
				maxa = max(maxa, bfs(i, j));
			}
		}
	}
	cout << _count << endl;
	cout << maxa << endl;
	return 0;
}

1251：仙岛求药

【题目描述】

少年李逍遥的婶婶病了，王小虎介绍他去一趟仙灵岛，向仙女姐姐要仙丹救婶婶。叛逆但孝顺的李逍遥闯进了仙灵岛，克服了千险万难来到岛的中心，发现仙药摆在了迷阵的深处。迷阵由M×N个方格组成，有的方格内有可以瞬秒李逍遥的怪物，而有的方格内则是安全。现在李逍遥想尽快找到仙药，显然他应避开有怪物的方格，并经过最少的方格，而且那里会有神秘人物等待着他。现在要求你来帮助他实现这个目标。

下图 显示了一个迷阵的样例及李逍遥找到仙药的路线。

【题目分析】

 【代码实现】

#include <bits/stdc++.h>

using namespace std;

int r, c;
bool a[25][25];
bool vis[25][25];
struct node {
	int x;
	int y;
	int step;
	node() {};
	node(int _x, int _y, int _step): x(_x), y(_y), step(_step) {};
} p1, p2;
int _next[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
void bfs() {
	memset(vis, 0, sizeof(vis));
	queue<node> que;
	que.push(p1);
	int x = p1.x;
	int y = p1.y;
	vis[x][y] = 1;
	bool flag = 1;
	while (!que.empty()) {
		x = que.front().x;
		y = que.front().y;
		int s = que.front().step;
		if (x == p2.x && y == p2.y) {
			cout << s << endl;
			flag = 0;
			break;
		}
		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 < r && ny < c && vis[nx][ny] == 0 && a[nx][ny] == 0) {
				vis[nx][ny] = 1;
				que.push(node(nx, ny, s + 1));
			}
		}
		que.pop();
	}
	if (flag) cout << -1 << endl;
}
int main() {
	//input data
	while (cin >> r >> c, !(r == 0 && c == 0)) {
		for (int i = 0; i < r; i++) {
			for (int j = 0; j < c; j++) {
				char ch;
				cin >> ch;
				if (ch == '.') a[i][j] = 0;
				if (ch == '#') a[i][j] = 1;
				if (ch == '@') p1 = node(i, j, 0);
				if (ch == '*') {
					p2 = node(i, j, 0);
					a[i][j] = 0;
				}
			}
		}
		bfs();
	}


	return 0;
}

1252：走迷宫

【题目描述】

一个迷宫由R行C列格子组成，有的格子里有障碍物，不能走；有的格子是空地，可以走。

给定一个迷宫，求从左上角走到右下角最少需要走多少步(数据保证一定能走到)。只能在水平方向或垂直方向走，不能斜着走。

【题目分析】

【代码实现】

#include <bits/stdc++.h>

using namespace std;

int r, c;
bool _map[45][45];
bool vis[45][45];
struct node {
	int x;
	int y;
	int step;
	node() {};
	node(int _x, int _y, int _step): x(_x), y(_y), step(_step) {};
};
int _next[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
queue<node> que;
void bfs() {
	que.push(node(0, 0, 1));
	vis[0][0] = 1;
	while (!que.empty()) {
		int x = que.front().x;
		int y = que.front().y;
		if (x == r-1 && y == c-1) {
			cout << que.front().step;
			break;
		}
		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 < r && ny < c && vis[nx][ny] == 0 && _map[nx][ny] == 0) {
				que.push(node(nx, ny, que.front().step + 1));
				vis[nx][ny] = 1;
			}
		}
		que.pop();
	}
}
int main() {
	//input data
	cin >> r >> c;
	for (int i = 0; i < r; i++) {
		for (int j = 0; j < c; j++) {
			char ch;
			cin >> ch;
			if (ch == '#')
				_map[i][j] = 1;
			else
				_map[i][j] = 0;
		}
	}
	bfs();

	return 0;
}

1253：抓住那头牛

【题目描述】

农夫知道一头牛的位置，想要抓住它。农夫和牛都位于数轴上，农夫起始位于点N(0≤N≤100000)，牛位于点K(0≤K≤100000)。农夫有两种移动方式：

1、从X移动到X−1或X+1，每次移动花费一分钟

2、从X移动到2×X，每次移动花费一分钟

假设牛没有意识到农夫的行动，站在原地不动。农夫最少要花多少时间才能抓住牛？

【题目分析】

 【代码实现】

#include <bits/stdc++.h>

using namespace std;

int n, k;
bool vis[100001];
queue<pair<int, int>>que;
int main() {
	//input data
	cin >> n >> k;
	que.push(make_pair(n, 0));
	vis[n] = 1;
	while (!que.empty()) {
		int f = que.front().first;
		int s = que.front().second;
		if (f == k) {
			cout << s;
			break;
		}
		if (f + 1 <= 100000 && vis[f + 1] == 0 ) {
			que.push(make_pair(f + 1, s + 1));
			vis[f + 1] = 1;
		}
		if (f - 1 >= 0 && vis[f - 1] == 0) {
			que.push(make_pair(f - 1, s + 1));
			vis[f - 1] = 1;
		}
		if (f * 2 <= 100000 && vis[f * 2] == 0 ) {
			que.push(make_pair(f * 2, s + 1));
			vis[f * 2] = 1;
		}
		que.pop();
	}
	return 0;
}

1254：走出迷宫

【题目描述】

当你站在一个迷宫里的时候，往往会被错综复杂的道路弄得失去方向感，如果你能得到迷宫地图，事情就会变得非常简单。

假设你已经得到了一个n×m的迷宫的图纸，请你找出从起点到出口的最短路。

【题目分析】

 【代码实现】

#include <bits/stdc++.h>

using namespace std;

struct node {
	int x;
	int y;
	int step;
	node() {};
	node(int _x, int _y, int _step): x(_x), y(_y), step(_step) {};
} p1, p2;
int a[205][205];
int vis[205][205];
int _next[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int r, c;
void bfs() {
	queue<node> que;
	memset(vis, 0, sizeof(vis));
	que.push(p1);
	vis[p1.x][p1.y] = 1;
	bool flag = 1;
	while (!que.empty()) {
		int x = que.front().x;
		int y = que.front().y;
		if (x == p2.x && y == p2.y) {
			cout << que.front().step << endl;
			flag = 0;
			break;
		}
		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 < r && ny < c && vis[nx][ny] == 0 && a[nx][ny] == 0) {
				que.push(node(nx, ny, que.front().step + 1));
				vis[nx][ny] = 1;
			}
		}
		que.pop();
	}
	if (flag) cout << "oop!" << endl;
}
int main() {
	//input data
	cin >> r >> c;
	char ch;
	for (int i = 0; i < r; i++) {
		for (int j = 0; j < c; j++) {
			cin >> ch;
			if (ch == '.')
				a[i][j] = 0;
			if (ch == '#')
				a[i][j] = 1;
			if (ch == 'S')
				p1 = node(i, j, 0);
			if (ch == 'T') {
				p2 = node(i, j, 0);
				a[i][j] = 0;
			}

		}
	}
	bfs();
	return 0;
}

1255：迷宫问题

【题目描述】

定义一个二维数组：

int maze[5][5] = {
0,1,0,0,0,
0,1,0,1,0,
0,0,0,0,0,
0,1,1,1,0,
0,0,0,1,0,
};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

【题目分析】

 【代码实现】

​
#include <bits/stdc++.h>

using namespace std;
const int maxn = 5;

struct node {
	int x;
	int y;
	node() {};
	node(int _x, int _y): x(_x), y(_y) {};
} rec[maxn][maxn];

int a[maxn][maxn];
int _next[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
queue<node> que;
stack<node> st;
bool vis[maxn][maxn];
void bfs() {
	que.push(node(4, 4));
	vis[4][4] = 1;
	while (!que.empty()) {
		int x = que.front().x;
		int y = que.front().y;
		if (x == 0 && y == 0) break;
		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 < 5 && ny < 5 && a[nx][ny] == 0 && vis[nx][ny] == 0) {
				que.push(node(nx, ny));
				rec[nx][ny] = node(x, y);
				vis[nx][ny] = 1;
			}
		}
		que.pop();
	}
}
int main() {
	//input data
	for (int i = 0; i < maxn; i++) {
		for (int j = 0; j < maxn; j++) {
			cin >> a[i][j];
		}
	}
	bfs();
	int x = 0, y = 0;
	while (x + y != 8) {
		printf("(%d, %d)\n", x, y);
		int nx = rec[x][y].x;
		int ny = rec[x][y].y;
		x = nx, y = ny;
	}
	printf("(%d, %d)\n", x, y);

	return 0;
}

​

1256：献给阿尔吉侬的花束

【题目描述】

阿尔吉侬是一只聪明又慵懒的小白鼠，它最擅长的就是走各种各样的迷宫。今天它要挑战一个非常大的迷宫，研究员们为了鼓励阿尔吉侬尽快到达终点，就在终点放了一块阿尔吉侬最喜欢的奶酪。现在研究员们想知道，如果阿尔吉侬足够聪明，它最少需要多少时间就能吃到奶酪。

迷宫用一个R×C的字符矩阵来表示。字符S表示阿尔吉侬所在的位置，字符E表示奶酪所在的位置，字符#表示墙壁，字符.表示可以通行。阿尔吉侬在1个单位时间内可以从当前的位置走到它上下左右四个方向上的任意一个位置，但不能走出地图边界。

【题目分析】

 【代码实现】

#include <bits/stdc++.h>

using namespace std;

struct node {
	int x;
	int y;
	int step;
	node() {};
	node(int _x, int _y, int _step): x(_x), y(_y), step(_step) {};
} p1, p2;
int a[205][205];
int vis[205][205];
int _next[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int r, c;
void bfs() {
	queue<node> que;
	memset(vis, 0, sizeof(vis));
	que.push(p1);
	vis[p1.x][p1.y] = 1;
	bool flag = 1;
	while (!que.empty()) {
		int x = que.front().x;
		int y = que.front().y;
		if (x == p2.x && y == p2.y) {
			cout << que.front().step << endl;
			flag = 0;
			break;
		}
		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 < r && ny < c && vis[nx][ny] == 0 && a[nx][ny] == 0) {
				que.push(node(nx, ny, que.front().step + 1));
				vis[nx][ny] = 1;
			}
		}
		que.pop();
	}
	if (flag) cout << "oop!" << endl;
}
int main() {
	//input data
	int T;
	cin >> T;
	while (T--) {
		cin >> r >> c;
		char ch;
		for (int i = 0; i < r; i++) {
			for (int j = 0; j < c; j++) {
				cin >> ch;
				if (ch == '.')
					a[i][j] = 0;
				if (ch == '#')
					a[i][j] = 1;
				if (ch == 'S')
					p1 = node(i, j, 0);
				if (ch == 'E') {
					p2 = node(i, j, 0);
					a[i][j] = 0;
				}

			}
		}
		bfs();
	}
	return 0;
}

1257：Knight Moves

【题目描述】

输入n代表有个n×n的棋盘，输入开始位置的坐标和结束位置的坐标，问一个骑士朝棋盘的八个方向走马字步，从开始坐标到结束坐标可以经过多少步。

 【题目分析】

 【代码实现】

#include <bits/stdc++.h>

using namespace std;

int L;
struct node {
	int x;
	int y;
	int step;
	node() {};
	node(int _x, int _y, int _step): x(_x), y(_y), step(_step) {};
} p1, p2;
int vis[305][305];
queue<node>que;
int _next[8][2] = {{1, 2}, {1, -2}, {2, 1}, {2, -1},
	{-1, 2}, {-1, -2}, {-2, 1}, {-2, -1}
};
int main() {
	//input data

	int x, y;
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> L;
		memset(vis, 0, sizeof(vis));
		que = queue<node>();
		cin >> x >> y;
		p1 = node(x, y, 0);
		cin >> x >> y;
		p2 = node(x, y, 0);
		que.push(p1);
		vis[p1.x][p1.y] = 1;
		while (!que.empty()) {
			if (que.front().x == p2.x && que.front().y == p2.y) {
				cout << que.front().step << endl;
				break;
			}
			for (int i = 0; i < 8; i++) {
				x = que.front().x + _next[i][0];
				y = que.front().y + _next[i][1];
				if (x >= 0 && y >= 0 && x < L && y < L && vis[x][y] == 0) {
					vis[x][y] = 1;
					que.push(node(x, y, que.front().step + 1));
				}
			}
			que.pop();
		}
	}
	return 0;
}

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

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

相关文章

「Vue面试题」动态给vue的data添加一个新的属性时会发生什么？怎样去解决的？

「Vue面试题」动态给vue的data添加一个新的属性时会发生什么？怎样去解决的？

一、直接添加属性的问题 我们从一个例子开始 定义一个p标签&#xff0c;通过v-for指令进行遍历 然后给botton标签绑定点击事件&#xff0c;我们预期点击按钮时&#xff0c;数据新增一个属性&#xff0c;界面也 新增一行 <p v-for"(value,key) in item" :key&q…
阅读更多...
Esp8266学习4. 基于Arduino的PWM与红外信号处理

Esp8266学习4. 基于Arduino的PWM与红外信号处理

Esp8266学习4. 基于Arduino的PWM与红外信号处理一、基本概念1. PWM2. ESP8266 的 PWM功能3. node-mcu 引脚图4. 模拟写入&#xff08;1&#xff09;analogWrite&#xff08;2&#xff09;修改频率 analogWriteFreq&#xff08;3&#xff09;调节分辨率二、使用 analogWrite实现…
阅读更多...
思腾合力深思系列 | 四款高性能 AI 服务器

思腾合力深思系列 | 四款高性能 AI 服务器

深思系列 AI 服务器涵盖多种 CPU 平台&#xff0c;支持按客户需求预装 OS、驱动、DL 框架、常用 DL 库&#xff0c;节省您大量的前期调试时间&#xff0c;开机即用。 一个简单的任务&#xff0c;若想要在 AI 的脑中形成清晰的思路&#xff0c;需要大量的实验和练习。从 AI 训练…
阅读更多...
05-CSS

05-CSS

今日目标能够说出 为什么要用定位能够说出 定位的 4 种分类能够说出 4 种定位各自的特点能够说出 为什么常用子绝父相布局能够写出 淘宝轮播图布局能够说出 显示隐藏的 3 种方式以及区别1. 定位(position) 介绍1.1 为什么使用定位我们先来看一个效果&#xff0c;同时思考一下用…
阅读更多...
ctfshow_crypto_妈呀完了writeup

ctfshow_crypto_妈呀完了writeup

目录一、题目原题二、解题步骤1.去掉01串中的空格2.把01二进制串转换成十进制数3.将十进制整数转换成bytes三、后记一、题目原题 题目给了一串01和一个png图片&#xff0c;打开看了提示说“图文无关”&#xff1a; 图片附件如下&#xff1a; 二、解题步骤 1.去掉01串中的空…
阅读更多...
3·8 妇女节特别策划 | 对话开源社里的“半边天”：多彩的她们，有别样的力量~...

3·8 妇女节特别策划 | 对话开源社里的“半边天”：多彩的她们，有别样的力量~...

三八妇女节Womens Day< 2023/03/08 >01职场女性 陈阳开源社理事长、微软云计算机与人工智能事业部首席产品经理一句话介绍自己&#xff1a;开源社区中的二进制女性向上滑动阅览采访Q1&#xff1a;能介绍一下自己目前正在做的职业或者项目嘛&#xff1f;白天在微软云计算和…
阅读更多...
Oracle调优日记

Oracle调优日记

Oracle调优日记前言前置知识联表查询Inner Joinleft joinright join环境背景描述问题展示最初代码问题解决过程优化一优化二优化三接口测试检查数据库连接总结前言 很难想想会在600条数据和4万条数据的两张表联表查询的的情况下&#xff0c;查询花了10多s。这里记录一下排查过…
阅读更多...
PMP考试是什么？介绍+资料分享

PMP考试是什么？介绍+资料分享

我来介绍一下PMP&#xff1a; PMP考试是由PMI组织和出题&#xff0c;严格评估项目管理人员知识技能是否具有高品质的资格认证考试。 1999年&#xff0c;PMP考试在所有认证考试中第一个获得ISO9001国际质量认证,从而成为全球权威的认证考试之一。下载PMP备考资料可看封面或在文…
阅读更多...
二叉树经典14题——初学二叉树必会的简单题

二叉树经典14题——初学二叉树必会的简单题

此篇皆为leetcode、牛客中的简单题型和二叉树基础操作&#xff0c;无需做过多讲解&#xff0c;仅付最优解。有需要的小伙伴直接私信我~ 目录 1.二叉树的节点个数 2.二叉树叶子节点个数 3.二叉树第K层节点个数 4.查找值为X的节点 5.leetcode——二叉树的最大深度 6.leetc…
阅读更多...
Spark（5）：RDD概述

Spark（5）：RDD概述

目录 0. 相关文章链接 1. 什么是RDD 2. RDD核心属性 3. 执行原理 0. 相关文章链接 Spark文章汇总 1. 什么是RDD RDD&#xff08;Resilient Distributed Dataset&#xff09;叫做弹性分布式数据集&#xff0c;是 Spark 中最基本的数据处理模型。代码中是一个抽象类&#x…
阅读更多...
淘宝widget链路方案总结

淘宝widget链路方案总结

目前widget生态已经做了大量的基建工作,同时在widget生态的演进过程中我们发现如何匹配用户的偏好一直以来是一个挑战工作&#xff0c;本文介绍了widget的整体链路。业务背景▐ widget介绍2020年底iOS推出了新版widget之后引起了一些声浪&#xff0c;但仍然很多苹果用户并不了…
阅读更多...
三、基本的select语句

三、基本的select语句

一、SQL概述 1、SQL背景知识 2、SQL语言排行 3、SQL分类 SQL语言在功能上主要分为如下3大类&#xff1a; DDL&#xff08;Data Definition Languages、数据定义语言&#xff09;&#xff0c;这些语句定义数据库、表、视图、索引等数据库对象&#xff0c;还可以用来创建、删除…
阅读更多...
MacOS + AndroidSDK + appium + 真手机（Android系统）环境搭建

MacOS + AndroidSDK + appium + 真手机（Android系统）环境搭建

需要的环境&#xff1a;Node.js version: ^14.17.0 || ^16.13.0 || >18.0.0NPM version > 8Java8python3Android SDK (通过Andriod Studio 安装)Appium client desktop (v1.19.1)install brew/bin/zsh -c "$(curl -fsSL https://gitee.com/cunkai/HomebrewCN/raw/ma…
阅读更多...
Docker启动问题docker is starting…

Docker启动问题docker is starting…

环境window 10 家庭最新版直接上官网安装的 Docker DeskTop问题启动应用后setting打开一直转圈圈&#xff1b;主界面一直显示 docker is starting…解决方案3.1 先确定hyper-v是否开启搜hyper-v&#xff0c;点击启动或关闭Windows功能如下,选中Hyper-V服务3.2 进入任务管理期&a…
阅读更多...
Hive 常用函数

Hive 常用函数

Hive 常用函数一、常用内置函数1、空字段赋值2、CASE WHEN THEN ELSE END3、行转列4、列转行5、窗口函数&#xff08;开窗函数&#xff09;6、Rank二、常用日期函数三、常用取整函数四、常用字符串操作函数五、集合操作一、常用内置函数 查看系统自带的函数show functions;显示…
阅读更多...
【AcWing】学了一坤时才明白的一道题

【AcWing】学了一坤时才明白的一道题

&#x1f386;音乐分享 &#xff08;点击链接可以听哦&#xff09; The Right Path - Thomas Greenberg 这道题小吉花了一坤时才弄明白&#xff0c;虽然花的时间有点长 但是至少是明白了 &#x1f60e;&#x1f60e;&#x1f60e;&#x1f60e;&#x1f60e;&#x1f60e; …
阅读更多...
Java程序占用CPU过高排查

Java程序占用CPU过高排查

使用 top 命令查看高CPU进程&#xff0c;执行命令后可以按 1 键查看各CPU 内核负载情况。CPU使用率主要看us、sy两个指标。假设 10760 是一个高CPU的进程。使用 top -H -p 查看 10760 的线程信息top -H -p 10760TIME列就是各个Java线程耗费的CPU时间。以线程ID 10952的线程为例…
阅读更多...
Msyql聚簇索引和非聚簇索引

Msyql聚簇索引和非聚簇索引

前提MySQL索引一直是面试中的常客&#xff0c;一提起索引&#xff0c;很多人都能答出来我知道Hash索引和B树索引&#xff0c;Hash是比较简单的&#xff0c;那么B树索引就有点复杂了。在创建表的时候&#xff0c;我们可以看到引擎有MyISAM , InnoDB等等&#xff0c;这两种是我们…
阅读更多...
ARM uboot 的移植3 -从 uboot 官方标准uboot开始移植

ARM uboot 的移植3 -从 uboot 官方标准uboot开始移植

一、选择合适的官方原版 uboot 1、官方原版 uboot 的版本 (1) 版本号。刚开始是 1.3.4 样式&#xff0c;后来变成 2009.08 样式。 (2) 新版和旧版的差别。uboot 的架构很早就定下来了&#xff0c;然后里面普遍公用的东西&#xff08;common 目录下、drivers 目录下、fs 目录…
阅读更多...
CSS快速入门

CSS快速入门

文章目录一、CSS是什么&#xff1f;语法规范引入方式二、CSS选择器标签选择器类选择器ID选择器通配符选择器后代选择器子选择器并集选择器伪类选择器三、常见元素属性字体属性文本属性背景属性圆角矩形元素的显示默认块级与行级元素盒子模式去除浏览器默认样式弹性布局一、CSS是…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023