[kuangbin专题1]简单搜索

已于 2022-03-18 23:59:46 修改
阅读量87 收藏 1
点赞数 1
分类专栏： kuangbin专题 文章标签： 深度优先 算法 蓝桥杯 广度优先
于 2022-03-18 15:19:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ghostttttttiii/article/details/123575783
版权

棋盘问题

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <cstring>
#include <set>
#include <cmath>
#include <map>
typedef long long ll;
using namespace std;
const int MN = 505;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;

int n, k;
char s[10][10];
int vis[10];
int ans;

void dfs(int x, int t) {
	if (t == k) {
		ans++;
		return ;
	}
	if (x == n + 1) {
		return ;
	}
	for (int i = 1; i <= n; i++) {
		if (vis[i] == 0 && s[x][i] == '#') {
			vis[i] = 1;
			dfs(x + 1, t + 1);
			vis[i] = 0;
		}
	}
	dfs(x + 1, t);
}


int main() {
	while (~scanf("%d %d", &n, &k)) {
		if (n == -1 && k == -1) {
			break;
		}
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				scanf(" %c", *(s + i) + j);
			}
		}
		ans = 0;
		memset(vis, 0, sizeof(vis));
		dfs(1, 0);
		printf("%d\n", ans);
	}
	return 0;
}

Dungeon Master

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <cstring>
#include <set>
#include <cmath>
#include <map>
typedef long long ll;
using namespace std;
const int MN = 505;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;

int L, R, C;
int ans;
int vis[35][35][35];
char s[35][35][35];
struct step {
	int x, y, c, sp;
	step(int tx, int ty, int tc, int ts): x(tx), y(ty), c(tc), sp(ts) {

	}
};

int gox[6] = {0, 1, 0, 0, 0, -1};

int goy[6] = {1, 0, 0, 0, -1, 0};

int goc[6] = {0, 0, 1, -1, 0, 0};
int ec, ex, ey;

int bfs(int c, int x, int y) {
	queue<step> que;
	que.push(step(x, y, c, 0));
	while (!que.empty()) {
		step p = que.front();
		que.pop();
		//printf("%d %d %d %d\n", p.x, p.y, p.c, p.sp);
		if (p.x == ex && p.y == ey && p.c == ec) {
			return p.sp;
		}
		int tx, ty, tc;
		for (int i = 0; i <= 5; i++) {
			tx = p.x + gox[i];
			ty = p.y + goy[i];
			tc = p.c + goc[i];
			if (tx >= 1 && tx <= R && ty >= 1 && ty <= C && tc >= 1 && tc <= L && s[tc][tx][ty] != '#' && vis[tc][tx][ty] == 0) {
				vis[tc][tx][ty] = 1;
				que.push(step(tx, ty, tc, p.sp + 1));
				//printf();
			}
		}
	}
	return 0;
}

void solve() {
	ans = 0;
	memset(vis, 0, sizeof(vis));
	int tx, ty, tc;
	for (int i = 1; i <= L; i++) {
		for (int j = 1; j <= R; j++) {
			for (int k = 1; k <= C; k++) {
				scanf(" %c", &s[i][j][k]);
				if (s[i][j][k] == 'S') {
					tc = i;
					tx = j;
					ty = k;
				}
				if (s[i][j][k] == 'E') {
					ec = i;
					ex = j;
					ey = k;
				}
			}
		}
	}
	int res = bfs(tc, tx, ty);
	if (res) {
		printf("Escaped in %d minute(s).\n", res);
	} else {
		printf("Trapped!\n");
	}
}

int main() {
	while (~scanf("%d %d %d", &L, &R, &C)) {
		if (L == 0 && R == 0 && C == 0) {
			break;
		}
		solve();
	}
	return 0;
}

Catch that cow

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <cstring>
#include <set>
#include <cmath>
#include <map>
typedef long long ll;
using namespace std;
const int MN = 505;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;

int vis[MAXN];
int N, K;
struct node {
	int x, cost;
	node(int tx, int tcost): x(tx), cost(tcost) {
	}

};

int solve() {
	queue<node> que;
	que.push(node(N, 0));
	while (!que.empty()) {
		node t = que.front();
		que.pop();
		//printf("%d %d\n", t.x, t.cost);
		if (t.x == K) {
			return t.cost;
		}
		if (t.x - 1 >= 0 && !vis[t.x - 1]) {
			vis[t.x - 1] = 1;
			que.push(node(t.x - 1, t.cost + 1));
		}
		if (t.x + 1 <= 100000 && !vis[t.x + 1]) {
			vis[t.x + 1] = 1;
			que.push(node(t.x + 1, t.cost + 1));
		}
		if (t.x * 2 <= 100000 && !vis[t.x * 2]) {
			vis[t.x * 2] = 1;
			que.push(node(t.x * 2, t.cost + 1));
		}
	}
}

int main() {
	scanf("%d %d", &N, &K);
	printf("%d", solve());
	return 0;
}

Find The Multiple

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <cstring>
#include <set>
#include <cmath>
#include <map>
typedef long long ll;
using namespace std;
const int MN = 65005;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;
#define IOS ios::sync_with_stdio(false);

int m;
int flag;
void dfs(int step, unsigned long long x) {
	if (step > 19 || flag == 1) {
		return ;
	}
	if (x % m == 0) {
		flag = 1;
		printf("%lld\n", x);
		return;
	}
	dfs(step + 1, x * 10);
	dfs(step + 1, x * 10 + 1);
}


int main() {
	while (scanf("%d", &m) && m) {
		dfs(1, 1);
		flag = 0;
	}
	return 0;
}

Prime Path

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <cstring>
#include <set>
#include <cmath>
#include <map>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
const int MN = 65005;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;
#define IOS ios::sync_with_stdio(false);

const int N = 10005;
bool isprime[N];
int a, b;
typedef pair<int, int> P;
int vis[N];

void sieve() {
	for (int i = 0; i <= N; i++) {
		isprime[i] = true;
	}
	isprime[0] = isprime[1] = 0;
	for (int i = 2; i <= N; i++) {
		if (isprime[i]) {
			//printf("%d\t", i);
			for (int j = 2 * i; j <= N; j += i) {
				isprime[j] = false;
			}
		}
	}
}

inline int getnum(int n4, int n3, int n2, int n1) {
	return n4 * 1000 + n3 * 100 + n2 * 10 + n1;
}

bool check(int n4, int n3, int n2, int n1) {
	int tmp = getnum(n4, n3, n2, n1);
	if (tmp >= 1000 && isprime[tmp] && vis[tmp] == 0) {
		return true;
	}
	return false;
}


void bfs() {
	queue<P> que;
	que.push(P(a, 0));
	vis[a] = 1;
	while (!que.empty()) {
		P k = que.front();
		que.pop();
		//printf("%d %d\n", k.first, k.second);
		if (k.first == b) {
			printf("%d\n", k.second);
			return ;
		}
		int n1 = k.first % 10;
		int n2 = k.first / 10 % 10;
		int n3 = k.first / 100 % 10;
		int n4 = k.first / 1000;
		for (int i = 0; i <= 9; i++) {
			int num;
			if (check(n4, n3, n2, i)) {
				num = getnum(n4, n3, n2, i);
				vis[num] = 1;
				que.push(P(num, k.second + 1));
			}
			if (check(n4, n3, i, n1)) {
				num = getnum(n4, n3, i, n1);
				vis[num] = 1;
				que.push(P(num, k.second + 1));
			}
			if (check(n4, i, n2, n1)) {
				num = getnum(n4, i, n2, n1);
				vis[num] = 1;
				que.push(P(num, k.second + 1));
			}
			if (check(i, n3, n2, n1)) {
				num = getnum(i, n3, n2, n1);
				vis[num] = 1;
				que.push(P(num, k.second + 1));
			}
		}
	}
	printf("Impossible\n");
}


int main() {
	int t;
	scanf("%d", &t);
	sieve();
	while (t--) {
		scanf("%d %d", &a, &b);
		bfs();
		memset(vis, 0, sizeof(vis));
	}
	return 0;
}

Shuffle'm Up

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <cstring>
#include <set>
#include <cmath>
#include <map>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
const int MN = 65005;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;
#define IOS ios::sync_with_stdio(false);



int pos = 1;
void solve() {
	int len;
	scanf("%d", &len);
	string s1, s2, s3, s, ss;
	cin >> s1 >> s2 >> s;
	ss = s1 + s2;
	int cnt = 0;
	while (1) {
		s3 = "";
		for (int i = 0; i < len; i++) {
			s3 = s3 + s2[i];
			s3 = s3 + s1[i];
		}
		cnt++;
		//cout << s3 << endl;
		if (s3 == s) {
			printf("%d %d\n", pos++, cnt);
			return ;
		}
		for (int i = 0; i < len; i++) {
			s1[i] = s3[i];
			s2[i] = s3[i + len];
		}
		//cout << s1 << "  " << s2 << endl;
		if (ss == s1 + s2) {
			printf("%d -1\n", pos++);
			return ;
		}
	}
}

int main() {
	int t;
	scanf("%d", &t);
	while (t--) {
		solve();
	}
	return 0;
}

Fire!

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <cstring>
#include <set>
#include <cmath>
#include <map>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
const int MN = 65005;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;
#define IOS ios::sync_with_stdio(false);

int R, C;
char s[1010][1010];
int fire[1010][1010];
int vis[1005][1005];
int go[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int sx, sy;
//int fx, fy;
typedef pair<int, int> P;
int pos = 0;

struct ff {
	int x, y;
	ff() {
	}
	ff(int tx, int ty): x(tx), y(ty) {
	}
} ;
ff Fire[1005];

void firetomap() {
	memset(fire, INF, sizeof(fire));
	queue<ff> que;
	for (int i = 0; i < pos; i++) {
		que.push(ff(Fire[i].x, Fire[i].y));
		fire[Fire[i].x][Fire[i].y] = 0;
	}
	while (!que.empty()) {
		ff t = que.front();
		que.pop();
		for (int i = 0; i <= 3; i++) {
			int tx = t.x + go[i][0];
			int ty = t.y + go[i][1];
			if (tx >= 1 && tx <= R  && ty >= 1 && ty <= C  && s[tx][ty] != '#' && fire[tx][ty] == INF) {
				fire[tx][ty] = fire[t.x][t.y] + 1;
				que.push(ff(tx, ty));
			}
		}
	}/*
	for (int i = 1; i <= R; i++) {
		for (int j = 1; j <= C; j++) {
			printf("%d ", fire[i][j]);
		}
		printf("\n");
	}*/
}

struct node {
	int x, y, time;
	node(int tx, int ty, int t): x(tx), y(ty), time(t) {
	}
};

void bfs() {
	firetomap();
	queue<node> que;
	vis[sx][sy] = 1;
	que.push(node(sx, sy, 0));
	while (!que.empty()) {
		node t = que.front();
		que.pop();
		//printf("%d %d %d\n", t.x, t.y, t.time);
		if (t.x == 1 || t.x == R  || t.y == 1 || t.y == C ) {
			printf("%d\n", t.time + 1);
			return ;
		}
		for (int i = 0; i <= 3; i++) {
			int tx = t.x + go[i][0];
			int ty = t.y + go[i][1];
			int tm = t.time + 1;
			if (tx >= 1 && tx <= R  && ty >= 1 && ty <= C  && vis[tx][ty] == 0 && s[tx][ty] != '#' && tm < fire[tx][ty] ) {
				vis[tx][ty] = 1;
				que.push(node(tx, ty, tm));
			}
		}
	}
	printf("IMPOSSIBLE\n");
}

int main() {
	int t;
	scanf("%d", &t);
	while (t--) {
		pos = 0;
		scanf("%d %d", &R, &C);
		for (int i = 1; i <= R; i++) {
			for (int j = 1; j <= C; j++) {
				scanf(" %c", *(s + i) + j);
				if (s[i][j] == 'J') {
					sx = i;
					sy = j;
				}
				if (s[i][j] == 'F') {
					Fire[pos].x = i;
					Fire[pos++].y = j;
				}
			}
		}
		bfs();
		memset(vis, 0, sizeof(vis));
		memset(Fire, 0, sizeof(Fire));
	}
	return 0;
}

迷宫问题

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <cstring>
#include <set>
#include <cmath>
#include <map>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
const int MN = 65005;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;
#define IOS ios::sync_with_stdio(false);
typedef pair<int, int> P;



int vis[10][10];
int maze[10][10];
int go[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

struct node {
	int x, y;
	string s;
	//node(int tx, int ty, const char *ss): x(tx), y(ty), s(ss) {
	//}
	node(int tx, int ty, string ts): x(tx), y(ty), s(ts) {
	}
};

string bfs() {
	queue<node> que;
	vis[0][0] = 1;
	que.push(node(0, 0, "(0, 0)\n"));
	while (!que.empty()) {
		node t = que.front();
		que.pop();
		int tx, ty;
		//cout << t.s;
		if (t.x == 4 && t.y == 4) {
			return t.s;
		}
		for (int i = 0; i <= 3; i++) {
			tx = t.x + go[i][0];
			ty = t.y + go[i][1];
			//	printf("%d %d\n", tx, ty);
			if (tx >= 0 && tx < 5 && ty >= 0 && ty < 5 && vis[tx][ty] == 0 && maze[tx][ty] == 0) {
				vis[tx][ty] = 1;
				string s = "(, )\n" ;
				char ch1 = '0' + tx, ch2 = '0' + ty;
				s.insert(s.begin() + 1, ch1);
				s.insert(s.begin() + 4, ch2);
				//cout << "S:" << s << endl;
				que.push(node(tx, ty, t.s + s));
			}
		}
	}
	return "Impossible\n";
}


int main() {

	for (int i = 0; i <= 4; i++) {
		for (int j = 0; j <= 4; j++) {
			scanf("%d", *(maze + i) + j);
		}
	}
	cout << bfs() << endl;
	return 0;
}

非常可乐

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <cstring>
#include <set>
#include <cmath>
#include <map>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
const int MN = 65005;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;
#define IOS ios::sync_with_stdio(false);
typedef pair<int, int> P;

struct node {
	int x, y, z, step;
	node(int tx, int ty, int tz, int c): x(tx), y(ty), z(tz), step(c) {
	}
};

int S, N, M;
int vis[105][105][105];
void bfs() {
	queue<node> que;
	que.push(node(0, 0, S, 0));
	int kk = S / 2;
	while (!que.empty()) {
		node t = que.front();
		que.pop();
		//printf("%d %d %d %d\n", t.z, t.x, t.y, t.step);
		if ((t.z == kk && t.x == kk) || (t.x == kk && t.y == kk) || (t.z == kk && t.y == kk)) {
			printf("%d\n", t.step);
			return;
		}
		if (vis[0][t.y][t.x + t.z] == 0) {
			vis[0][t.y][t.x + t.z] = 1;
			que.push(node(0, t.y, t.x + t.z, t.step + 1));
		}
		if (vis[t.x][0][t.z + t.y] == 0) {
			vis[t.x][0][t.z + t.y] = 1;
			que.push(node(t.x, 0, t.y + t.z, t.step + 1));
		}
		if (t.z + t.x > N && vis[N][t.y][t.z + t.x - N] == 0) {
			vis[N][t.y][t.z + t.x - N] = 1;
			que.push(node(N, t.y, t.z - (N - t.x), t.step + 1));
		} else if (t.z + t.x <= N && vis[t.x + t.z][t.y][0] == 0) {
			vis[t.x + t.z][t.y][0] = 1;
			que.push(node(t.x + t.z, t.y, 0, t.step + 1));
		}
		if (t.y + t.z > M && vis[t.x][M][t.y + t.z - M] == 0) {
			vis[t.x][M][t.y + t.z - M] = 1;
			que.push(node(t.x, M, t.y + t.z - M, t.step + 1));
		} else if (t.y + t.z <= M && vis[t.x][t.y + t.z][0] == 0) {
			vis[t.x][t.y + t.z][0] = 1;
			que.push(node(t.x, t.y + t.z, 0, t.step + 1));
		}
		if (t.y + t.x > N && vis[N][t.y + t.x - N][t.z] == 0) {
			vis[N][t.y + t.x - N][t.z] = 1;
			que.push(node(N, t.y + t.x - N, t.z, t.step + 1));
		} else if (t.x + t.y <= N && vis[t.x + t.y][0][t.z] == 0) {
			vis[t.x + t.y][0][t.z] = 1;
			que.push(node(t.x + t.y, 0, t.z, t.step + 1));
		}
		if (t.y + t.x > M && vis[t.x + t.y - M][M][t.z] == 0) {
			vis[t.x + t.y - M][M][t.z] = 1;
			que.push(node(t.x + t.y - M, M, t.z, t.step + 1));
		} else if (t.y + t.x <= M && vis[t.x + t.y][0][t.z] == 0) {
			vis[t.x + t.y][0][t.z] = 1;
			que.push(node(t.x + t.y, 0, t.z, t.step + 1));
		}
	}
	printf("NO\n");
}

int main() {
	while (scanf("%d %d %d", &S, &N, &M) && (S + N + M)) {
		if (S % 2 != 0) {
			printf("NO\n");
			continue;
		}
		bfs();
		memset(vis, 0, sizeof(vis));
	}
	return 0;
}

eva_can(not)survive
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kuangbin 模板
09-08
kuangbin 模板
kuangbin的ACM模板（2018.7更新）
07-25
kuangbin说他之前的老模板有...本来这个东西是公开的免费的，但是上传资源积分至少1个，不支持免费分享。大家如果没有积分的话可以给我私信，我不忙的时候一定会发的~~~欢迎关注~~~~~~kuangbin的ACM模板（2018.7更新）
kuangbin 专题一 简单搜索
qw991的博客
02-23 242
kuangbin 专题一 简单搜索1.POJ1321棋盘问题[DFS]2.POJ2251Dungeon Master[三维空间BFS]3.POJ3278 Catch That Cow[BFS]4.POJ3279 Fliptile[状态压缩+DFS]5.POJ1426 Find The Multiple[BFS]6.POJ3126 Prime Path[BFS]7.POJ3087 Shuffle'm Up[简单模拟]8.POJ3414 Pots[BFS]9.FZU2150 Fire Game[BFS+暴力]1
[周专题系列]kuangbin 专题1 简单搜索
鱼竿钓鱼干
03-13 894
[周专题系列]kuangbin 专题1 简单搜索 题单链接 知识点 题目 类型 题目 棋盘问题 思路 代码 在这里插入代码片 棋盘问题 思路 代码 在这里插入代码片 棋盘问题 思路 代码 在这里插入代码片 棋盘问题 思路 代码 在这里插入代码片 棋盘问题 思路 代码 在这里插入代码片 棋盘问题 思路 代码 在这里插入代码片 棋盘问题 思路 代码 在这里插
kuangbin专题 专题1 简单搜索
YeYuShengFan_的博客
06-12 181
kuangbin专题
kuangbin专题一 简单搜索
weixin_51671868的博客
08-04 292
​ 在一个给定形状的棋盘中，摆放棋子，要求同一行和同一列最多只能有一个棋子。​ 这实际上就是 nnn 皇后的改版，直接使用 DFSDFSDFS 搜就行了。 AcWing 1096. 地牢大师 - AcWing 题意 ​ 在一个三维地牢中，给定每一层的地图，并标注起点和终点，判断能否从起点到达终点，能就输出移动的最短路径长度。​ 二维走迷宫的拓展，在使用 BFSBFSBFS 的时候加多一维就行了。 1100. 抓住那头牛 - AcWing题库 题意 ​ 农夫和牛在一个一维数轴上，农夫在点 NNN，牛
kuangbin专题一 简单搜索 题解思路
Joovo的博客
12-07 654
近来想起来补一下基础，确实从基础题里还能学到很多，搜索这方面更是自己所欠缺的，总结一下简单搜索的结题思路。A - 棋盘问题 - POJ 1321 思路： 不规则棋盘上的八皇后问题，回溯检查一下即可。B - Dungeon Master POJ - 2251 思路： 三维的迷宫，向六个方向bfs，跟平面迷宫一样。C - Catch That Cow POJ - 3278 思路： 1xN
Kuangbin专题 - 简单搜索 - D - Fliptile
Myriad Dreamin 愿逐将属于我的奇迹
01-04 255
关灯问题需要注意的一点是：单调不能完成的任务是一定不能完成的，没有反复开关灯的操作…单调向下枚举… 这里我观察到了(i-1,j)点为1时是必须开一次灯的。 枚举第一行是否开灯即可（因为没有作为是否参考的第零行）。 很巧妙的是，这样参考下来，检查最后一行是否all0，如果不是，这样的开灯方式就一定不能完成操作。#include <cstdio> #include <cstring> int ma
kuangbin专题1简单搜索第一题棋盘问题
qq_45466182的博客
04-12 169
kuangbin棋盘问题 #include <iostream> using namespace std; char t[10][10]; int h[10]; int s[10]; int n,m; long sum = 0; void dfs(int k, int heng) { if(k == 0) { sum++; return; } if(heng > n) { return; }
kuangbin专题-简单搜索
small_whl的博客
04-03 1367
kuangbin专题题目一 11 迷宫问题 #include<iostream> #define MAX 105 using namespace std; struct node{ int x; int y; int pre; }fp[MAX]; int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}}; int g[MAX][MAX]; int a[MAX][MAX]; int m=0; int pos=0; void bfs() {
kuangbin的ACM模板（新）.pdf
11-15
Contents 1 字符串处理 5 1.1 KMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 1.2 e-KMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ...
kuangbin的ACM模板（新）_模板_kuangbin_kuangbinacm_ACM_
09-29
kuangbin的ACM模板动态规划计算几何：线与线求交，线与面求交，求凸包，半平面求交等若干图论问题：最小生成树 最短路 强连通分量、桥和割点 等
kuangbin的ACM模板（新）.zip_kuangbin ACM算法模板
09-19
kuangbin巨巨 ACM模板~ 有需要的朋友可以下载了~
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5101
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
牛客网刷题 | BC118 N个数之和
m0_64000959的博客
06-09 480
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入数字N，然后输入N个数，计算这N个数的和。第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。输出为一行，为第二行输入的“N个整数之和”的计算结果。使用数组的方式 先将用户输入的几个数字分别存起来定义一个变量将它数字的和加起来然后输出 代码 2 ： 输入n个数相加，应该想到循
【排序算法】总结篇
SWsunlight的博客
06-08 941
排序对比
力扣416 分割等和子集 Java版本
最新发布
m0_47066863的博客
06-14 346
然后就可以考虑用0-1背包的思路来解决这个问题，这里元素的值就是当前元素的价值和重量，背包的容量就是子集元素和的一半，最终需要确定这个背包里是否能够正好装进价值为子集和一半的时候。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。找出两个子集，让这两个子集的和相等可以转化思路为：找到一个子集，这个子集的和是子集中所有元素和的一半。解释：数组可以分割成 [1, 5, 5] 和 [11]。输入：nums = [1,5,11,5]输入：nums = [1,2,3,5]
LeetCode 算法：轮转数组c++
小金牛来了
06-09 666
LeetCode 算法：轮转数组c++
并查集板子llkkyyy
08-19
并查集是一种常用的数据结构，用于管理一个不相交集合的数据。在并查集中，每个元素都有一个父节点指向它所属的集合的代表元素。通过查找和合并操作，可以判断两个元素是否属于同一个集合，并将它们合并到同一个集合中。 在解决某些问题时，可以使用并查集进行优化。例如，在区间查询中，可以通过优化并查集的查询过程，快速找到第一个符合条件的点。 对于拆边（destroy）操作，一般的并查集无法直接实现这个功能。但是可以通过一个巧妙的方法来解决。首先，记录下所有不会被拆除的边，然后按照逆序处理这些指令。遇到拆边操作时，将该边重新加入并查集中即可。 在实现并查集时，虽然它是一种树形结构，但只需要使用数组就可以实现。可以通过将每个元素的父节点记录在数组中，来表示元素之间的关系。通过路径压缩和按秩合并等优化策略，可以提高并查集的效率。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [「kuangbin带你飞」专题五并查集专题题解](https://blog.csdn.net/weixin_51216553/article/details/121643742)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *3* [并查集（详细解释+完整C语言代码）](https://blog.csdn.net/weixin_54186646/article/details/124477838)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值