bfs:种树、迷宫问题、学霸的迷宫

最新推荐文章于 2022-01-24 00:03:10 发布

向上Claire

最新推荐文章于 2022-01-24 00:03:10 发布

阅读量182

点赞数

分类专栏：蓝桥算法

本文链接：https://blog.csdn.net/weixin_44522477/article/details/105243712

版权

蓝桥同时被 2 个专栏收录

205 篇文章 6 订阅

订阅专栏

算法

88 篇文章 1 订阅

订阅专栏

bfs

种树（有多个出发点）

问题描述
　　小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1。
　　小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。
　　这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，这四小块空地都将变为有草的小块。
　　请告诉小明，k 个月后空地上哪些地方有草。
输入格式
　　输入的第一行包含两个整数 n, m。
　　接下来 n 行，每行包含 m 个字母，表示初始的空地状态，字母之间没有空格。如果为小数点，表示为空地，如果字母为 g，表示种了草。
　　接下来包含一个整数 k。
输出格式
　　输出 n 行，每行包含 m 个字母，表示 k 个月后空地的状态。如果为小数点，表示为空地，如果字母为 g，表示长了草。
样例输入
4 5
.g…
…..
..g..
…..
2
样例输出
gggg.
gggg.
ggggg
.ggg.
评测用例规模与约定
　　对于 30% 的评测用例，2 <= n, m <= 20。
　　对于 70% 的评测用例，2 <= n, m <= 100。
　　对于所有评测用例，2 <= n, m <= 1000，1 <= k <= 1000

package BFS;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.LinkedList;
import java.util.Scanner;

public class 种树 {

	private static int[][] vis;
	public static void main(String[] args)throws IOException {
		// TODO Auto-generated method stub
		int n,m,k;
		Scanner sc=new Scanner(System.in);
		n=sc.nextInt();//行
		m=sc.nextInt();//列
		sc.nextLine();//消除符号
		int[] dx = {1, 0, -1, 0};
		int[] dy = {0, 1, 0, -1};
		vis = new int[1000][1000];
		LinkedList<Node> queue=new LinkedList<Node>();
        for (int i = 0; i < n; i++) {
            String line = sc.nextLine();
            for (int j = 0; j < m; j++) {
                if (line.charAt(j) == 'g') {
                	//初始化q
                    queue.addLast(new Node(i, j,0));
                    vis[i][j] = 1;//标记数组
                }else
                	vis[i][j]=0;
            }
        }
        k = sc.nextInt();
        while(!queue.isEmpty()){
        	Node b=queue.removeFirst();
        	int month=b.month;
        	if(month<k){
        		for(int i=0;i<4;i++){
        			int nx=b.i+dx[i];
        			int ny=b.j+dy[i];
        			 if (0 <= nx && nx < n && 0 <= ny && ny < m && vis[nx][ny] == 0) {
                         vis[nx][ny] = 1;
                         queue.addLast(new Node(nx, ny, month + 1));
        		}
        	}
        }
	}
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (vis[i][j] == 1) writer.write('g');//让他缓冲一下在输出
                else writer.write('.');
            }
            writer.write('\n');
        }
        writer.flush(); 
	}
	private static class Node{
		int i;
		int j;
		int month;
		public Node(int i,int j,int month){
			this.i=i;
			this.j=j;
			this.month=month;
		}
	}
}

迷宫问题

在这里插入图片描述

学霸的迷宫

题目

问题描述

　　学霸抢走了大家的作业，班长为了帮同学们找回作业，决定去找学霸决斗。但学霸为了不要别人打扰，住在一个城堡里，城堡外面是一个二维的格子迷宫，要进城堡必须得先通过迷宫。因为班长还有妹子要陪，磨刀不误砍柴功，他为了节约时间，从线人那里搞到了迷宫的地图，准备提前计算最短的路线。可是他现在正向妹子解释这件事情，于是就委托你帮他找一条最短的路线。

输入格式

　　第一行两个整数n， m，为迷宫的长宽。
 　　接下来n行，每行m个数，数之间没有间隔，为0或1中的一个。0表示这个格子可以通过，1表示不可以。假设你现在已经在迷宫坐标(1,1)的地方，即左上角，迷宫的出口在(n,m)。每次移动时只能向上下左右4个方向移动到另外一个可以通过的格子里，每次移动算一步。数据保证(1,1)，(n,m)可以通过。

输出格式

　　第一行一个数为需要的最少步数K。
 　　第二行K个字符，每个字符∈{U,D,L,R},分别表示上下左右。如果有多条长度相同的最短路径，选择在此表示方法下字典序最小的一个。

样例输入

Input Sample 1:
 3 3
 001
 100
 110
 
Input Sample 2:
 3 3
 000
 000
 000

样例输出

Output Sample 1:
 4
 RDRD
 
Output Sample 2:
 4
 DDRR

数据规模和约定

　　有20%的数据满足：1<=n,m<=10
 　　有50%的数据满足：1<=n,m<=50
 　　有100%的数据满足：1<=n,m<=500。

为什么就是不出来

package BFS;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Scanner;

public class 学霸的迷宫 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int m=sc.nextInt();
		sc.next();
		int[][] vis=new int[n+1][m+1];
		LinkedList<Node> queue=new LinkedList<Node>();
		String[] onePath = {"U","D","L","R"};//分别表示向上、下、左、右行走
		String s="";
		for(int i=1;i<=n;i++){
			s=sc.next();
			for(int j=1;j<=s.length();j++){
				vis[i][j]=s.charAt(j-1)-'0';
			}
		//	sc.next();
		}
		//o表示可以通过，1才表示不可以通过
		queue.addLast(new Node(1,1,0,""));//添加开始的入口//表示从顶点(1,1)出发
		int[] dx = {-1, 1, 0, 0};
		int[] dy = {0, 0, -1, 1};//上下左右，两个连着看
		int minStep = Integer.MAX_VALUE;  //用于记录到达最终顶点所需最少步数
		String minPath = "";         //用于记录到达最终顶点路径的最小字典序序列
		
		while(!queue.isEmpty()){
			Node b=queue.removeFirst();
			int x=b.x;
			int y=b.y;
			if(x==n&&y==m){
				if(minStep>b.step){
					minStep=b.step;
					minPath=b.path;
				}else if(minStep==b.step){
					if(judge(minPath,b.path))//当minPath字典序大于begin.step时
						minPath=b.path;
				}
				continue;//此处已经是终点，不需要进行下面bfs遍历
			}
				for(int i=0;i<4;i++){
					int nx=b.x+dx[i];
					int ny=b.y+dy[i];
					int step=b.step+1;//步数加1
					String path=b.path+onePath[i];
					if(1<=nx&&nx<=n&&1<=ny&&ny<=m&&vis[nx][ny]==0){//当nx,ny是可到达的顶点时
						queue.addLast(new Node(nx,ny,step,path));
						vis[nx][ny]=1; //到达该顶点后，标记该顶点不可到达，此处奥秘是大大减少了检索次数（如果换成其父母顶点不可到达，则会运行超时）
					}
				}
		}
		
		System.out.println(minStep+"\n"+minPath);
		
	}
	public static class Node{
		int x;//当前到达位置横坐标
		int y;//当前到达位置纵坐标
		int step;//行走到当前顶点所用总步数
		String path;//行走到当前顶点的具体路径
		public Node(int x,int y,int step,String path){
			this.x=x;
			this.y=y;
			this.step=step;
			this.path=path;
		}
	}
    //依据字典序{D,L,R,U}，比较字符串A和B的大小，如果A > B返回true，否则返回false(PS:两者字符个数相同)
    public static boolean judge(String A, String B) {
        char[] arrayA = A.toCharArray();
        char[] arrayB = B.toCharArray();
        for(int i = 0, len = A.length();i < len;i++) {
            if(arrayA[i] < arrayB[i])
                return false;
        }
        return true;
    }

}

就是一个sc.nextLine(),害我找了半天

package BFS;
import java.util.LinkedList;
import java.util.Scanner;

public class 学霸的迷宫 {
	public static class Node{
		int x;//当前到达位置横坐标
		int y;//当前到达位置纵坐标
		int step;//行走到当前顶点所用总步数
		String path;//行走到当前顶点的具体路径
		public Node(int x,int y,int step,String path){
			this.x=x;
			this.y=y;
			this.step=step;
			this.path=path;
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int m=sc.nextInt();
		//就是这里，害我找了半天！！！！！！
		sc.nextLine();//此处特别注意，输入完整数，下面接着输出字符串，此处处理换行操作
		int[][] vis=new int[n+1][m+1];
		LinkedList<Node> queue=new LinkedList<Node>();
		String[] onePath = {"U","D","L","R"};//分别表示向上、下、左、右行走
		String s="";
		for(int i=1;i<=n;i++){
			s=sc.next();
			for(int j=1;j<=s.length();j++){
				vis[i][j]=s.charAt(j-1)-'0';
			}
		//	sc.next();
		}
		sc.close();
		//o表示可以通过，1才表示不可以通过
		queue.addLast(new Node(1,1,0,""));//添加开始的入口//表示从顶点(1,1)出发
		int[] dx = {-1, 1, 0, 0};
		int[] dy = {0, 0, -1, 1};//上下左右，两个连着看
		int minStep = Integer.MAX_VALUE;  //用于记录到达最终顶点所需最少步数
		String minPath = "";         //用于记录到达最终顶点路径的最小字典序序列
		
		while(!queue.isEmpty()){
			Node b=queue.removeFirst();
			int x=b.x;
			int y=b.y;
			if(x==n&&y==m){
				if(minStep>b.step){
					minStep=b.step;
					minPath=b.path;
				}else if(minStep==b.step){
					if(judge(minPath,b.path))//当minPath字典序大于begin.step时
						minPath=b.path;
				}
				break;//此处已经是终点，不需要进行下面bfs遍历
			}
			
				for(int i=0;i<4;i++){
					int nx=b.x+dx[i];
					int ny=b.y+dy[i];
					int step=b.step+1;//步数加1
					String path=b.path+onePath[i];
					if(1<=nx&&nx<=n&&1<=ny&&ny<=m&&vis[nx][ny]==0){//当nx,ny是可到达的顶点时
						queue.addLast(new Node(nx,ny,step,path));
						vis[nx][ny]=1; //到达该顶点后，标记该顶点不可到达，此处奥秘是大大减少了检索次数（如果换成其父母顶点不可到达，则会运行超时）
					}
				}
		}
		
		System.out.println(minStep);
		System.out.println(minPath);
		
	}

    //依据字典序{D,L,R,U}，比较字符串A和B的大小，如果A > B返回true，否则返回false(PS:两者字符个数相同)
    public static boolean judge(String A, String B) {
        char[] arrayA = A.toCharArray();
        char[] arrayB = B.toCharArray();
        for(int i = 0, len = A.length();i < len;i++) {
            if(arrayA[i] < arrayB[i])
                return false;
        }
        return true;
    }

}

在这里插入图片描述

优化一点点的解法

package BFS;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;

public class 学霸的迷宫1 {
	//广度优先搜素适用于最优解 最短路径 例如迷宫
	public static class Node{
		int x;//当前到达位置横坐标
		int y;//当前到达位置纵坐标
		int step;//行走到当前顶点所用总步数
		String s;//行走到当前顶点的具体路径
		public Node(int x,int y,int step,String s){
			this.x=x;
			this.y=y;
			this.step=step;
			this.s=s;
		}
	}
	public static void main(String[] args) throws IOException {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));//输入数据较多时效率高
		String[] s = br.readLine().split(" ");
		int m=Integer.parseInt(s[0]);
		int n=Integer.parseInt(s[1]);
		char[][] a=new char[m][n];
		int[][] res=new int[m][n];
		for(int i=0;i<m;i++){
			a[i]=br.readLine().toCharArray();
		}
		Queue<Node> queue=new LinkedList<>();//ArrayList也可
		queue.add(new Node(0,0,0,""));//起始点
		while(!queue.isEmpty()) {
			Node p=queue.poll();//出队列
			int x=p.x;
			int y=p.y;
			int step=p.step;
			String s1=p.s;
			res[x][y]=1;
			//判断是否到达出口
			if(x==m-1&&y==n-1) {
				System.out.println(p.step);
				System.out.println(p.s);
				break;
			}
			//下  这样就能满足字典序最小
			if(x+1<m&&res[x+1][y]!=1&&a[x+1][y]!='1') {
				queue.add(new Node(x+1,y,step+1,s1+"D"));//加上之前的路径这样到达出口时的结点的路径就是完整的路径
				res[x+1][y]=1;//添加进去了就要标记为1  很重要不然会超时或者死循环
			}
			//左
			if(y-1>=0&&res[x][y-1]!=1&&a[x][y-1]!='1') {
				queue.add(new Node(x,y-1,step+1,s1+"L"));
				res[x][y-1]=1;
			}
			//上
			if(x-1>=0&&res[x-1][y]!=1&&a[x-1][y]!='1') {
				queue.add(new Node(x-1,y,step+1,s1+"U"));
				res[x-1][y]=1;
			}	
			//右
			if(y+1<n&&res[x][y+1]!=1&&a[x][y+1]!='1') {
				queue.add(new Node(x,y+1,step+1,s1+"R"));
				res[x][y+1]=1;
			}
		}		
	}

}

向上Claire

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
bfs:种树、迷宫问题、学霸的迷宫

bfs种树（有多个出发点）问题描述　　小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1。　　小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。　　这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，这四小块空地都将变为有草的小块。　　请告诉小明，k 个月后空地上哪些地方有草。输入格式...
复制链接

扫一扫