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;
}
}
}
}
扫一扫
971
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
