kuangbin算法刷题:专题一简单搜索

最新推荐文章于 2022-05-20 13:23:05 发布
最新推荐文章于 2022-05-20 13:23:05 发布
阅读量179 收藏
点赞数
分类专栏： 算法 java 文章标签： 算法 dfs bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_45289690/article/details/116546697
版权

专题一简单搜索

文章目录


这个专题主要是使用bfs，dfs来解决问题

1. 棋盘问题原题链接

给定一个指定形状的棋盘，和一定数量的棋子，使用旗子去填棋盘，要使得所有的旗子不在同一行，或同一列，求总共有多少种摆法。(旗子都相同，没有区别)

这个题与八皇后问题相似，使用dfs探索出所有符合条件的路。


import java.util.Scanner;

public class Main {

	private String[] map;
	private int[] visted;
	private int n;
	private int k;
	private int res;

	public static void main(String[] args) {
		new Main().resolve();
	}

	public void resolve() {
		Scanner scanner = new Scanner(System.in);
		while (true) {
			String s = scanner.nextLine();
			String[] ss = s.split(" ");
			n = Integer.parseInt(ss[0]);
			k = Integer.parseInt(ss[1]);
			if (n == -1 || k == -1) {
				break;
			}
			map = new String[n];
			visted = new int[n];
			for (int i = 0; i < n; i++) {
				map[i] = scanner.nextLine();
			}
			dfs(0, k);
			System.out.println(res);
			res = 0;
		}
	}

	private void dfs(int line, int k_now) {
		if (k_now == 0) {
			res++;
			return;
		}
		if (line == n) {
			return;
		}
		for (int i = 0; i < n; i++) {
			if (map[line].charAt(i) == '#' && visted[i] == 0) {
				visted[i] = 1;
				dfs(line + 1, k_now - 1);
				visted[i] = 0;
			}
		}
		dfs(line + 1, k_now);
	}

}

2. dungeon master原题链接

迷宫问题，一个3D迷宫，寻找最短出路。我这里使用了两种方法

  • (超时)使用dfs可以找到所有路径，从中找出最短的路径即可获得最优解。

    因为每条路都探索，并且有重复走过的路程，比如 (1,2,3)->(1,2,2)->(1,2,1) , (1,2,3)->(1,1,3)->(1,1,1)->(1,2,1)->(1,2,2)->(1,2,1)，后面有重复的路(1,2,2)->(1,2,1)，也就是说在第二次探索路的时候，如果将第一次探索的结果存起来，在到(1,2,2)的时，就可以知道还有一步即可到达终点(1,2,1)。

    那我们是不是可以把距离存起来呢，答案是否定的，因为需要的是最短距离，dfs是深度优先是做不到的，就拿上面的举例，假设(1,2,3)和(1,2,1)不是起点和终点，而是需要经过的点，如果先走的是第一条我们标记(1,2,3)->(1,2,1)距离为2，之后当搜索到(1,2,3)时，我们只需加上2，便是到(1,2,1)的距离。但是要是先走的是第二条，就是加6了，显然不合理。

    因此可以想到要是用bfs自然可以解决这个问题，bfs每次循环，即得到下一步可以到达的所以点，因此一点是最短的路。

    import java.util.Scanner;

public class Main {
	private static int[] x_move = { 1, -1, 0, 0, 0, 0 };
	private static int[] y_move = { 0, 0, 1, -1, 0, 0 };
	private static int[] z_move = { 0, 0, 0, 0, 1, -1 };
	private String[][] maze;
	private int l;
	private int r;
	private int c;
	private int[][][] visted;
	private int res = Integer.MAX_VALUE;

	public static void main(String[] args) {
		new Main().resolve();
	}

	public void resolve() {
		Scanner scanner = new Scanner(System.in);
		while (true) {
			String firstLine = scanner.nextLine();
			String[] ss = firstLine.split(" ");
			l = Integer.parseInt(ss[0]);
			r = Integer.parseInt(ss[1]);
			c = Integer.parseInt(ss[2]);
			if (l == 0 || r == 0 || c == 0) {
				break;
			}
			maze = new String[l][r];
			visted = new int[l][r][c];

			int S_x = -1;
			int S_y = -1;
			int S_z = -1;
			for (int i = 0; i < l; i++) {
				for (int j = 0; j < r; j++) {
					maze[i][j] = scanner.nextLine();
				}
				scanner.nextLine();
			}
			here: for (int i = 0; i < l; i++) {
				for (int j = 0; j < r; j++) {
					if ((S_y = maze[i][j].indexOf("S")) != -1) {
						S_z = i;
						S_x = j;
						break here;
					}
				}
			}

			dfs(S_x, S_y, S_z, 0);
			if (res == Integer.MAX_VALUE) {
				System.out.println("Trapped!");
			} else
				System.out.println("Escaped in " + res + " minute(s).");
			res = Integer.MAX_VALUE;
		}
	}

	private void dfs(int x, int y, int z, int steps) {
		if (x < 0 || x >= c || y < 0 || y >= r || z < 0 || z >= l || visted[z][y][x] == 1
				|| maze[z][y].charAt(x) == '#') {
			return;
		}
		if (maze[z][y].charAt(x) == 'E') {
			res = res > steps ? steps : res;
			return;
		}
		visted[z][y][x] = 1;
		for (int i = 0; i < 6; i++) {
			dfs(x + x_move[i], y + y_move[i], z + z_move[i], steps + 1);
		}
		visted[z][y][x] = 0;
	}
}

  • bfs解法

    
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		new Main().resolve();
	}

	class Point {
		int x;
		int y;
		int z;
		int step;

		public Point(int x, int y, int z, int step) {
			this.x = x;
			this.y = y;
			this.z = z;
			this.step = step;
		}
	}

	private static int[] x_move = { 1, -1, 0, 0, 0, 0 };
	private static int[] y_move = { 0, 0, 1, -1, 0, 0 };
	private static int[] z_move = { 0, 0, 0, 0, 1, -1 };
	private String[][] maze;
	private int l;
	private int r;
	private int c;
	private int[][][] visted;
	private Queue<Point> queue;
	private int res = -1;

	public void resolve() {
		Scanner scanner = new Scanner(System.in);
		while (true) {
			String firstLine = scanner.nextLine();
			String[] ss = firstLine.split(" ");
			l = Integer.parseInt(ss[0]);
			r = Integer.parseInt(ss[1]);
			c = Integer.parseInt(ss[2]);
			if (l == 0 || r == 0 || c == 0) {
				break;
			}
			maze = new String[l][r];
			visted = new int[l][r][c];

			int S_x = -1;
			int S_y = -1;
			int S_z = -1;
			for (int i = 0; i < l; i++) {
				for (int j = 0; j < r; j++) {
					maze[i][j] = scanner.nextLine();
				}
				scanner.nextLine();
			}
			here: for (int i = 0; i < l; i++) {
				for (int j = 0; j < r; j++) {
					if ((S_x = maze[i][j].indexOf("S")) != -1) {
						S_z = i;
						S_y = j;
						break here;
					}
				}
			}
			queue = new LinkedList<Point>();
			queue.offer(new Point(S_x, S_y, S_z, 0));
			visted[S_z][S_y][S_x] = 1;
			Bfs();
			if (res == -1) {
				System.out.println("Trapped!");
			} else
				System.out.println("Escaped in " + res + " minute(s).");
			res = -1;
		}
	}

	private void Bfs() {
		while (!queue.isEmpty()) {
			Point now = queue.poll();
			for (int i = 0; i < 6; i++) {
				int x = now.x + x_move[i];
				int y = now.y + y_move[i];
				int z = now.z + z_move[i];
				if (x < 0 || x >= c || y < 0 || y >= r || z < 0 || z >= l || visted[z][y][x] == 1
						|| maze[z][y].charAt(x) == '#') {
					continue;
				}
				Point next = new Point(x, y, z, now.step + 1);
				if (maze[z][y].charAt(x) == 'E') {
					res = next.step;
					return;
				}
				visted[z][y][x] = 1;
				queue.offer(next);
			}
		}
	}
}

3. Catch That Cow原题链接

给定两个数字，求其中一个数字至少经过多少次+1，-1，*2操作后可以成为另一个数。

一次有三个选择，+1，-1或*2。使用bfs。

分析一下可以进行剪枝，比如start比end小，只能进行-1（比如81->1，加一和乘二显然是不可以的，所以就是80）



import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {

	static int[] ans = new int[100001];
	static boolean[] visited = new boolean[100001];

	public static void resolve() {
		Queue<Integer> queue = new LinkedList<Integer>();
		int start;
		int end;
		Scanner scanner = new Scanner(System.in);
		String string = scanner.nextLine();
		String[] ss = string.split(" ");
		start = Integer.parseInt(ss[0]);
		end = Integer.parseInt(ss[1]);
		queue.offer(start);
		visited[start] = true;
		if (end <= start) {
			System.out.println(start - end);
			return;
		}
		while (!queue.isEmpty()) {
			int now = queue.poll();

			for (int i = 0; i < 3; i++) {
				int next = now;
				if (i == 0) {
					next -= 1;
				} else if (i == 1) {
					next += 1;
				} else {
					next *= 2;
				}
				if (next == end) {
					System.out.println(ans[now] + 1);
					return;
				} else if (next >= 0 && next <= 100000 && visited[next] == false) {
					queue.offer(next);
					visited[next] = true;
					ans[next] = ans[now] + 1;
				}
			}

		}

	}

	public static void main(String[] args) {
		resolve();
	}
}
[kuangbin带你飞]专题一 做题顺序与题解 【简单搜索】
指弹键盘哼民谣
02-23 8064
随便说点： 博主正在刷kuangbin专题的题目，初学者，没接触过什么算法，刷题的初衷是备战蓝桥杯，后来发现了算法资料大多是针对acm的，挑选kuangbin专题入门也是如此，毕竟这样分类看起来比较有目的的刷题。 所以有的代码比较冗余，越往后面的题解代码变化越大， 代码的风格和算法思想也是在一步步的学习和进步，多多包容，互相借鉴。 建议做题顺序： 11 2 12 3 1 8 13 6 14 ...
[kuangbin带你飞]专题四 做题顺序与题解 【最短路练习】
指弹键盘哼民谣
02-23 5880
随便说点： 博主正在刷kuangbin专题的题目，初学者，没接触过什么算法，刷题的初衷是备战蓝桥杯，后来发现了算法资料大多是针对acm的，挑选kuangbin专题入门也是如此，毕竟这样分类看起来能达到比较有目的的刷题。 所以有的代码比较冗余，越往后面的题解代码变化越大， 代码的风格和算法思想也是在一步步的学习和进步，多多包容，互相借鉴。 建议做题顺序： dijk: 1 7 4 10 3 2 1...
kuangbin算法刷题:专题四最短路径练习
qq_45289690的博客
05-08 201
专题四 最短路练习 文章目录专题四 最短路练习2. Frogger[原题链接][8]3. Heavy Transportation[原题链接][9]1. Til the Cows Come Home[原题链接][7] 2. Frogger原题链接 湖中有n块石头，编号从1到n，有两只青蛙，A在1号石头上，B在2号石头上，B想去看望A。但是A的石头超出了他的跳跃范围。因此，B使用其他石头作为中间站，通过一系列的小跳跃到达她。两块石头之间的青蛙距离被定义为两块石头之间所有可能路径上的最小必要跳跃距离，某条路径的
Kuangbin算法刷题 专题五 并查集
qq_45289690的博客
05-22 177
专题五 并查集 并查集的使用主要是在 有传递关系的问题，比如 已知A和B有关系1，记为{A,B}，C和D有关系1,即{C，D} ，现在告诉A和C有关系1，就可以得到{A,B,C,D}都有关系1。 在比如剪刀石头布中即三者循环克制的关系，已知A和B的关系及B和C的关系，可以推出A和C的关系。 已知X和Y同性，Y和Z同性，可以推出X和Z同性，只要知道X和Y的性别相对关系，以及Y和Z的性别相对关系 X和Y相距d1，Y和Z相距为d2,则可以推出X和Z的距离(这里的距离指同一方向） … 其实在
kuangbin 专题一：简单搜索 非常可乐
weixin_45867800的博客
09-30 1044
kuangbin刷题总结——专题一：简单搜索 非常可乐 题目链接： 传送门 #include<cstdio> #include<iostream> using namespace std; int gcd(int a,int b) { return !b ? a : gcd(b,a%b); } int main() { int a,b,c; while(scanf("%d%d%d",&a,&b,&c)) { if(a == 0 &&
kuangbin 专题一：简单搜索 Fire!
weixin_45867800的博客
09-30 162
kuangbin刷题总结——专题一：简单搜索 Fire! 题目链接： 传送门 题目来自voj 采用zmyhh的Description #include<bits/stdc++.h> using namespace std; const int N = 1005; char theMap[N][N]; bool used[N][N]; int btime[N][N]; int r, c, cnt, fsx[N], jsx, fsy[N], jsy, op[4][2] = {{0,1},{0,-1}
kuangbin专题一：简单搜索 棋盘问题
weixin_45867800的博客
09-27 173
kuangbin刷题总结——专题一：简单搜索 棋盘问题 题目链接: https://vjudge.net/problem/POJ-1321 #include<iostream> #include<string.h> using namespace std; char map[10][10]; int n, k, ans = 0, used[10]; void dfs(int level, int chosen) { //到达终点状态 if (chosen == k) {
“kuangbin带你飞”专题计划——专题十四：数论基础
I_have_a_world的博客
05-13 427
[kuangbin带你飞]专题1-23 写在前面 1.目前还没啥写的。开始时间：2021-05-13（其实博客上看得到该博客创建时间的） 2.上一个专题刷的是网络流（博客总结），属于第一次接触。本来想的是一周特别高效，然后一周略划水，结果是五一期间高效，工作日有课略划水。还好，每个题都写了博客，收获很多 3.这个专题，我想应该每个题都涉及了不一样的知识吧。也建议每个题都写博客 4.写个感受？有与高四刷书的感觉了，激动，期待，轻松辛苦，有时候一本书要一个月才刷完，这不代表我效率低，只能代表这.
刷题记录 kuangbin带你飞专题九：连通图
Raki_J的博客
06-10 394
这个专题实属虐心…各种debug搞到自闭 不过进步就是在自闭中产生的… 后面被反向边逼迫使用了链式前向星建图（双修？） 1.POJ 1236 Network of Schools 任务一：求出入度为0的连通分量数量 任务二：求加多少条边能让整个图强连通 对于第二问，因为要使整个图强连通，贪心的拿每一个出度为0的点对入度为0的点加边，这样下来最小的加边数就是max（入度，出度） #include <cstdio> #include <iostream> #include <alg
[kuangbin带你飞] 专题一 简单搜索 题解（超详细注释，史上最强题解）
m0_60962081的博客
05-20 5194
[kuangbin带你飞] 专题一 简单搜索 题解（超详细注释，史上最强题解）
刷题记录 kuangbin带你飞专题六：最小生成树
Raki_J的博客
05-28 344
全是憨批题的专题 可能是为了在并查集之后给人恢复信心 简略写一下 1.POJ 1251 Jungle Roads 模板题，把字母转化为数字 #include <iostream> #include <cstring> #include <cstdio> #include <algorithm> #include <set> #include <queue> #include <vector> #include <cma
[kuangbin带你飞]专题五 做题顺序与题解 【并查集】
指弹键盘哼民谣
02-23 3050
随便说点： 博主正在刷kuangbin专题的题目，初学者，没接触过什么算法，刷题的初衷是备战蓝桥杯，后来发现了算法资料大多是针对acm的，挑选kuangbin专题入门也是如此，毕竟这样分类看起来比较有目的的刷题。 所以有的代码比较冗余，越往后面的题解代码变化越大， 代码的风格和算法思想也是在一步步的学习和进步，多多包容，互相借鉴。 建议做题顺序： 并查集模板题：2 3 1 并查集应用：12 1...
[kuangbin带你飞]专题六 做题顺序与题解 【最小生成树】
指弹键盘哼民谣
02-23 3672
随便说点： 博主正在刷kuangbin专题的题目，初学者，没接触过什么算法，刷题的初衷是备战蓝桥杯，后来发现了算法资料大多是针对acm的，挑选kuangbin专题入门也是如此，毕竟这样分类看起来比较有目的的刷题。 所以有的代码比较冗余，越往后面的题解代码变化越大， 代码的风格和算法思想也是在一步步的学习和进步，多多包容，互相借鉴。 建议做题顺序： 做最小生成树专题没最短路和并查集专题时那么吃力...
题解 计算几何刷题记录
Love_Jacques的博客
05-12 399
题单源自洛谷：16408 计算几何 - 从入门到跳楼： 入门： P1652 圆： 题意：给n个不相交的圆，求从Point1到Point2一条曲线最少穿越多少个圆。 思路：n个圆都不相交，且连接两点的曲线可以任意弯曲延展，则除了只包括point1或者只包括point2的圆不能避开，其他都可以避开（同时包括point1和point2不会被影响）。 代码： #include<bits/stdc++.h> #define eps 1e-6 using namespace std; struct p
基于规则系统的表示与推理的动物专家系统（使用正向推理和反向推理两种方法）
qq_45289690的博客
11-28 6192
基于规则系统的表示与推理的动物专家系统（使用正向推理和反向推理两种方法） 文章目录基于规则系统的表示与推理的动物专家系统（使用正向推理和反向推理两种方法）解题思路代码运行结果 解题思路 正向推理： 从用户提供的初始已知事实出发，从规则集中选出一条可适用的规则进行推理，并将推理到的结论加入事实库，重复上述过程，直到求得了所要的解或者规则集无法在扩展为止。算法描述如下： （1） DATA<-初始数据库 （2） Util DATA 满足结束条件以前，do （3） Begin a) 在规则集中选择一条适用于
java 从url下载图片或者网页
qq_45289690的博客
07-07 312
java 从url下载图片或者网页 import java.io.*; import java.net.HttpURLConnection; import java.net.MalformedURLException; import java.net.URL; public class URLDownloader extends Thread { private String url; private String filename; @Override public v
Java在算法比赛中快速读写数据
qq_45289690的博客
05-21 306
Java在算法比赛中快速读写数据 java里面的Scanner类确实能让我们实现方便以各种形式读取数据。但是效率是不高的，在算法比赛中，数据量大时就容易TLE。下面本人在刷kuangbin算法题时对同一个题的一个时间对比。 下面两份代码一个使用了Scanner一个没有使用。除此之外其他都一样。 可以看到时间对比。差了5倍！！！仅仅一个Scanner。 import java.io.BufferedReader; import java.io.InputStreamReader; import java.u
java学习之泛型
qq_45289690的博客
06-19 145
文章目录泛型泛型类泛型接口泛型方法擦拭法通配符 泛型 我们常用的容器(List，Set，Map)都采用了泛型； 泛型就是编写模板代码来适应任意类型； 泛型的好处是使用时不必对类型进行强制转换，它通过编译器对类型进行检查； 注意：泛型是一种语法糖，泛型是在编译的时候，会进行类型擦除(后面有介绍)，也就是说泛型对于虚拟机来说是不可见的。 泛型类 /** * 此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型 * 在实例化泛型类时，必须指定T的具体类型 *
探索ACM竞赛核心算法：kuangbin模板解析
- 图论算法：如深度优先搜索（DFS）、广度优先搜索（BFS）、最小生成树（Kruskal、Prim算法）、最短路径（Dijkstra、Bellman-Ford、Floyd-Warshall算法）。 - 动态规划：从简单的背包问题到复杂的区间动态规划和状态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值