## [kuangbin带你飞]专题一 简单搜索 题解

poj1321 感觉这题是八皇后的变形，一开始无脑搜索，对于每次每个点的n^2搜索，超时了，后来像八皇后那样，对每次每行搜索，这样每次都是n的复杂度的搜索了，而且还是逐层递增的往下搜索，所以也并不是到n，也不会有n^2那样的有t!阶乘的答案出现，好啦，bb多了

``````import java.util.Scanner;

public class poj1321 {

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()) {
n = in.nextInt();
k = in.nextInt();
if(n==-1 && k==-1)
break;
ans = 0;
ch = new char[n][n];
c = new boolean[n];
for(int i=0;i<n;i++)
ch[i] = in.next().toCharArray();
dfs(0,0);
System.out.println(ans);
}
}

static int n,k;
static long ans = 0;
static char[][] ch;
static boolean[] c;

static void dfs(int i,int m) {
if(m>=k) {
ans++;
return;
}
if(i>=n)
return;
for (int j = 0; j < n; j++)
if (ch[i][j] == '#' && !c[j]) {
c[j] = true;
dfs(i + 1,m+1);
c[j] = false;
}
dfs(i + 1,m);

}
}
``````

poj2251 这题一模一样的java代码，内存溢出了，对java很不友善呐

``````#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>
using namespace std;

char map[35][35][35];
int vis[35][35][35];
int k,n,m,sx,sy,sz,ex,ey,ez;
int to[6][3] = {{0,0,1},{0,0,-1},{0,1,0},{0,-1,0},{1,0,0},{-1,0,0}};//上下东西南北

struct node
{
int x,y,z,step;
};

int check(int x,int y,int z)//检查是否可走
{
if(x<0 || y<0 || z<0 || x>=k || y>=n || z>=m)//越界判断
return 1;
else if(map[x][y][z] == '#')
return 1;
else if(vis[x][y][z])
return 1;
return 0;
}

int bfs()
{
node u,v;
queue<node> Q;
u.x = sx,u.y = sy,u.z = sz;
u.step = 0;
vis[sx][sy][sz] = 1;
Q.push(u);
while(!Q.empty())
{
u = Q.front();
Q.pop();
if(u.x == ex && u.y == ey && u.z == ez)
return u.step;
for(int i = 0; i<6; i++)
{
v.x = u.x+to[i][0];
v.y = u.y+to[i][1];
v.z = u.z+to[i][2];
if(check(v.x,v.y,v.z))
continue;
vis[v.x][v.y][v.z] = 1;
v.step = u.step+1;
Q.push(v);
}
}
return 0;
}

int main()
{
int i,j,r;
while(scanf("%d%d%d",&k,&n,&m),n+m+k)
{
for(i = 0; i<k; i++)
{
for(j = 0; j<n; j++)
{
scanf("%s",map[i][j]);
for(r = 0; r<m; r++)
{
if(map[i][j][r] == 'S')
{
sx = i,sy = j,sz = r;
}
else if(map[i][j][r] == 'E')
{
ex = i,ey = j,ez = r;
}
}
}
}
memset(vis,0,sizeof(vis));
int ans;
ans = bfs();
if(ans)
printf("Escaped in %d minute(s).\n",ans);
else
printf("Trapped!\n");
}

return 0;
}``````

poj3278  记得标记标记标记！！！

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

public class poj3278 {

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
n = in.nextInt();
k = in.nextInt();
System.out.println(bfs());
}

static int n,k;
static boolean[] vis = new boolean[100005];

static int bfs() {
Queue<Node> q = new LinkedList<Node>();//poj不支持<> 要写<Node>
q.add(new Node(n, 0));
vis[n] = true;
while(!q.isEmpty()) {
Node u = q.poll();
if(u.x == k)
return u.t;
if(k>u.x  && u.x+1<=100001 && !vis[u.x+1]) {
q.add(new Node(u.x+1, u.t+1));
vis[u.x+1] = true;
}
if(u.x>=0 && u.x-1>=0 && !vis[u.x-1]) {
q.add(new Node(u.x-1, u.t+1));
vis[u.x-1] = true;
}
if(k>u.x && 2*u.x<=100001 && !vis[2*u.x]) {
q.add(new Node(2*u.x, u.t+1));
vis[2*u.x] = true;
}
}
return -1;
}

static class Node {
int x,t;
public Node(int x,int t) {
this.x = x;
this.t = t;
}
}

}``````

poj1426 java的long是10位 c++的longlong是19位，java用bfs+大数类做这题内存超出，c++的bfs也超时，不过呢，c++的dfsAC了，这么神奇的么？？思想也差不多，不过bfs不会剪枝，dfs找到一个解就return所有,最后我还试了下，java的大数+dfs，超时了，证明c++好很多，对java不友善，不过用数论+搜索的方式来写会好很多。网上有

``````#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
using namespace std;

int flag,n;
void dfs(long long int t,int k)
{

if(flag==1)
return;
if(t%n==0)
{
flag=1;
cout<<t<<endl;
return;
}
if(k==19)
return;
dfs(t*10,k+1);
dfs(t*10+1,k+1);
return;
}

int main()
{
while(cin>>n)
{
if(n==0)break;
flag=0;
dfs(1,1);
}
return 0;
}
``````

poj3126 bfs 暴力到没朋友，1000-9999的素数就1000多个，把他们存在list里面，然后每次都枚举1000多个，撑死10次找不到答案就是impossble了吧

``````import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;

public class poj3126 {

public static void main(String[] args) {
is[1] = true;
for(int i=2;i<10000;i++)
if(!is[i])
for(int j=2*i;j<10000;j+=i)
is[j] = true;
for(int i=1000;i<10000;i++)
if(!is[i])
list.add(i);
Scanner in = new Scanner(System.in);
int T = in.nextInt();
while(T-->0) {
for(int i=0;i<10000;i++)
vis[i] = false;
int ans = bfs(in.nextInt(),in.nextInt());
if(ans==-1)
System.out.println("Impossible");
else
System.out.println(ans);
}

}

static boolean is[] = new boolean[10000];
static boolean vis[] = new boolean[10000];
static List<Integer> list = new ArrayList<Integer>();

static class Node implements Comparable<Node>{
int x,k;
public Node(int x,int k) {
this.x = x;
this.k = k;
}
@Override
public int compareTo(Node o) {
return this.k - o.k;
}

}

static int bfs(int x,int y) {
Queue<Node> q = new LinkedList<Node>();
q.add(new Node(x,0));
vis[x] = true;
while(!q.isEmpty()) {
Node u = q.poll();
//			System.out.println(u.x+"   "+u.k);
if(u.x == y)
return u.k;
for(int i=0;i<list.size();i++)
if(!is[list.get(i)] && !vis[list.get(i)] && check(""+u.x,""+list.get(i))) {
vis[list.get(i)] = true;
q.add(new Node(list.get(i), u.k+1));
}
}

return -1;
}

static boolean check(String x,String y) {
int t=0;
for(int i=0;i<4;i++)
if(x.charAt(i)!=y.charAt(i))
t++;
return t==1;
}

}
``````

poj3414  这题和hdu 1495 非常可乐这题很像，就多了个打印路径，注意的是copy类似的if的时候改动的东西别忘记不改了，还有注意标记标记标记

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

public class poj3414 {

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
A = in.nextInt();
B = in.nextInt();
C = in.nextInt();
bfs();
}

static int A,B,C;
static boolean[][] vis = new boolean[105][105];
static String[] s = new String[] {"-1","FILL(1)","DROP(1)","POUR(1,2)","FILL(2)","DROP(2)","POUR(2,1)"};

static class Node {
int a,b,t;
String s;
public Node(int a,int b,int t,String s) {
this.a = a;
this.b = b;
this.t = t;
this.s = s;
}
}

static void bfs() {
Queue<Node> q = new LinkedList<Node>();
q.add(new Node(0, 0, 0,""));
vis[0][0] = true;
while(!q.isEmpty()) {//1.加满a 2.倒光a 3.a->b 4.加满b 5.倒光b 6.b->a
Node u = q.poll();
if(u.a==C || u.b==C) {
System.out.println(u.t);
for(char c:u.s.toCharArray())
System.out.println(s[c-'0']);
return;
}
if(u.a<A) {//1.
Node v = new Node(A, u.b, u.t+1,u.s+1);
if(!vis[v.a][v.b]) {
vis[v.a][v.b] = true;
q.add(v);
}
}

if(u.a>0) {//2.
Node v = new Node(0, u.b, u.t+1,u.s+2);
if(!vis[v.a][v.b]) {
vis[v.a][v.b] = true;
q.add(v);
}
}

if(u.a>0 && u.b<B) {//3.
Node v;
if(u.a > B-u.b)
v = new Node(u.a-(B-u.b), B, u.t+1,u.s+3);
else
v = new Node(0, u.a+u.b, u.t+1,u.s+3);
if(!vis[v.a][v.b]) {
vis[v.a][v.b] = true;
q.add(v);
}
}

if(u.b<B) {//4.
Node v = new Node(u.a, B, u.t+1,u.s+4);
if(!vis[v.a][v.b]) {

vis[v.a][v.b] = true;
q.add(v);
}
}

if(u.b>0) {//5.
Node v = new Node(u.a, 0, u.t+1,u.s+5);
if(!vis[v.a][v.b]) {
vis[v.a][v.b] = true;
q.add(v);
}
}

if(u.b>0 && u.a<A) {//6.
Node v;
if(u.b > A-u.a)
v = new Node(A, u.b-(A-u.a), u.t+1,u.s+6);
else
v = new Node(u.a+u.b, 0, u.t+1,u.s+6);
if(!vis[v.a][v.b]) {
vis[v.a][v.b] = true;
q.add(v);
}
}

}

System.out.println("impossible");
}

}``````

fzu2150 WA了20次，很无奈，感觉和别人写的差不多，最后才AC，我觉得是判断最后有没全点燃出了问题吧,所以最后的java代码也过了，唉

``````#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>
#include <vector>
using namespace std;

#define inf 0x3f3f3f3f

char ch[15][15];
bool vis[15][15];
int T,n,m,all=0,ans=inf;
int dx[4] = {1,0,-1,0};
int dy[4] = {0,1,0,-1};

struct node
{
int x,y,t;
};

queue<node> q;
vector<node> V;
node u,v;

bool ok(int x,int y){//检查是否可走
return x>=0 && x<n && y>=0 && y<m && !vis[x][y] && ch[x][y]=='#';
}

void init(){
memset(vis,false,sizeof vis);
while(!q.empty())
q.pop();
}

bool check(){
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(ch[i][j]=='#' && !vis[i][j])
return false;
return true;
}

int bfs(){
int sum=0,t=0;
while(!q.empty()){
u = q.front();
q.pop();
t = u.t;
sum++;

for(int i=0;i<4;i++)
if(ok(u.x+dx[i],u.y+dy[i])){
vis[u.x+dx[i]][u.y+dy[i]] = true;
v.x = u.x+dx[i];
v.y = u.y+dy[i];
v.t = u.t+1;
q.push(v);
}
}
return t;
}

int main(){

scanf("%d",&T);
for(int k=1;k<=T;k++){
ans = inf;
V.clear();
scanf("%d%d",&n,&m);
for(int i=0;i<n;i++)
scanf("%s",&ch[i]);

for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(ch[i][j]=='#') {
u.x = i;
u.y = j;
u.t = 0;
V.push_back(u);
}

for(int i=0;i<V.size();i++)
for(int j=i;j<V.size();j++)
{
init();
q.push(V[i]);
q.push(V[j]);
vis[V[i].x][V[i].y] = true;
vis[V[j].x][V[j].y] = true;
int tmp = bfs();
if(check())
ans = min(ans,tmp);
}

printf("Case %d: ",k);
if (ans==inf)
printf("-1\n");
else
printf("%d\n",ans);
}

return 0;
}``````

uva11624 用java做过的题，可以用c++重做一次了，因为java又超时了。两次BFS，首先把开始的F（火）入队，然后进行BFS 并用times数组记录到达每个位置的时间（初始化为INF，不可达则为INF），然后进行逃跑路线的BFS，当满足基本条件（不越界，未被访问），再满足到达某点时间小于该点的times，则说明在火到达之前，到此位置。如此进行，知道到达边界或者队列为空也没到达（IMPOSSIBLE）；一开始的想法是很暴力的，每遇到一个火就bfs一次，复杂度很高，缺不知道把所有的火放进去，然后只需要一次bfs，再加人的一次bfs即可

``````#include<iostream>
#include<stdio.h>
#include<vector>
#include<map>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<set>
#include<queue>
#include<cmath>
#define INF 0x3f3f3f3f
using namespace std;
const int N = 1005;
int dir[4][2] = {{-1,0},{0,1},{1,0},{0,-1}};
int n,m;
int st_x,st_y;
bool vis[N][N];
int times[N][N];
int step[N][N];
char ch[N][N];
struct P{
int x,y,s;
P(){}
P(int px,int py,int ps):x(px),y(py),s(ps){}
};
queue<P> q;

bool check(int x, int y){
return x>=0 && x<n && y>=0 && y<m && !vis[x][y] && ch[x][y]!='#';
}

void clear_q(){
while(!q.empty())
q.pop();
}

void bfs_fire(){
while(!q.empty()){
P cur = q.front();
q.pop();
for(int i = 0; i < 4; ++i){
int nx = cur.x + dir[i][0];
int ny = cur.y + dir[i][1];
if(check(nx,ny)){
vis[nx][ny] = true;
times[nx][ny] = times[cur.x][cur.y] + 1;
q.push(P(nx,ny,times[nx][ny]));
}
}
}
}

int bfs(int x, int y){
step[x][y] = 0;
q.push(P(x,y,0));
vis[x][y] = true;
while(!q.empty()){
P cur = q.front();
q.pop();
if(cur.x == 0 || cur.x == n-1 || cur.y == 0 || cur.y == m-1){
return step[cur.x][cur.y] + 1;
}
for(int i = 0; i < 4; ++i){
int nx = cur.x + dir[i][0];
int ny = cur.y + dir[i][1];
if(check(nx,ny) && step[cur.x][cur.y] + 1 < times[nx][ny]){
step[nx][ny] = step[cur.x][cur.y] + 1;
vis[nx][ny] = true;
q.push(P(nx,ny,step[nx][ny]));
}
}
}
return -1;
}

int main()
{
ios::sync_with_stdio(false);//取消同步，反正就是输入快了
int t;
cin >> t;
while(t--){
cin >> n >> m;
memset(times,INF,sizeof(times));
memset(vis,false,sizeof(vis));
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
cin >> ch[i][j];
if(ch[i][j] == 'J'){
st_x = i;
st_y = j;
}
if(ch[i][j] == 'F'){
vis[i][j] = true;
times[i][j] = 0;
q.push(P(i,j,0));
}
}
}
bfs_fire();

clear_q();//清空队列
memset(vis,false,sizeof(vis));//初始化

int ans = bfs(st_x,st_y);
if(ans == -1){
cout << "IMPOSSIBLE" <<endl;
}
else{
cout << ans << endl;
}
}

return 0;
}
``````

poj3984

``````import java.util.Scanner;
import java.util.Stack;

//迷宫问题
public class poj3984 {

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
for(int i=0;i<5;i++)
for(int j=0;j<5;j++)
maze[i][j] = in.nextInt();
dis.push(new Node(0, 0));
vis[0][0] = true;
dfs(0,0);

}

static int n=5;
static int[][] maze = new int[5][5];
static boolean[][] vis = new boolean[5][5];
static int[] dx = new int[] {1,0,-1,0};
static int[] dy = new int[] {0,1,0,-1};
static Stack<Node> dis = new Stack<Node>();
static Stack<Node> ans = new Stack<Node>();

static void dfs(int x,int y) {
if(x==4 && y==4) {
while(!dis.isEmpty())
ans.push(dis.pop());
while(!ans.isEmpty()) {
Node p = ans.pop();
System.out.println("("+p.x+", "+p.y+")");
}
return;
}
for(int i=0;i<4;i++)
if(x+dx[i]>=0 && x+dx[i]<5 && y+dy[i]>=0 && y+dy[i]<5 && maze[x+dx[i]][y+dy[i]]==0 && !vis[x+dx[i]][y+dy[i]]) {
dis.push(new Node(x+dx[i], y+dy[i]));
vis[x+dx[i]][y+dy[i]] = true;
dfs(x+dx[i],y+dy[i]);
vis[x+dx[i]][y+dy[i]] = false;
if(dis.isEmpty())//还是因为java的公用机制，不过这样也可以在找到答案后提早退出
return;
dis.pop();
}
}

static class Node{
int x,y;
public Node(int x, int y) {
this.x = x;
this.y = y;
}
}
}``````

hdu1241

``````import java.util.Scanner;

public class hdu1241 {

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()) {
n = in.nextInt();
if(n==0)
break;
m = in.nextInt();
ch = new char[n][m];
vis = new int[n][m];
for(int i=0;i<n;i++)
ch[i] = in.next().toCharArray();
int t=0;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(ch[i][j]=='@' && vis[i][j]==0)
dfs(++t,i,j);
System.out.println(t);
}
}

static int n,m;
static int[][] vis;
static char[][] ch;

static int[] dx = new int[] {1,1,1,0,0,-1,-1,-1};
static int[] dy = new int[] {0,-1,1,1,-1,1,0,-1};

static void dfs(int t,int x,int y) {
vis[x][y] = t;

for(int i=0;i<8;i++)
if(x+dx[i]>=0 && x+dx[i]<n && y+dy[i]>=0 && y+dy[i]<m && ch[x+dx[i]][y+dy[i]]=='@' && vis[x+dx[i]][y+dy[i]]==0)
dfs(t,x+dx[i],y+dy[i]);

}

}
``````

hdu1495

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

public class hdu1495 {

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()) {
s = in.nextInt();
a = in.nextInt();
b = in.nextInt();
if(s==0 && a==0 && b==0)
break;
if(b>a) {//让a是a，b里面最大的，方便判断，不过我觉得这里是累赘
int temp = a;
a = b;
b = temp;
}
vis = new boolean[a+1][b+1];//0~n有n个状态,所以起码开n+1个空间
int ans = bfs();
if(ans==-1)
System.out.println("NO");
else
System.out.println(ans);
}

}

static int s,a,b;//代表的是最大容量，并不是此时水的容量
static boolean[][] vis;//二维可以表示三维,用java记得初始化全局数组

static class Node {
int s,a,b,t;
public Node(int s,int a,int b,int t) {
this.s = s;
this.a = a;
this.b = b;
this.t = t;
}
}

static int bfs() {
if(s%2==1)//奇数不可能平分
return -1;

Node node = new Node(s, 0, 0, 0);//初始状态

Queue<Node> q = new LinkedList<>();
vis[node.a][node.b] = true;
q.add(node);
while(!q.isEmpty()) {
Node u = q.poll();

if(u.s==s/2 && u.a ==s/2)
return u.t;//终止条件

//列举6个状态 s->a, s->b, a->s, a->b, b->s, b->a

//放在这就是一个，会被共用，java的new的公用机制太恶心了
//			Node v = new Node(-1, -1, -1, u.t+1);//下一状态 -1表达还没初始化

//s->a
if(u.s!=0 && u.a!=a) {//不为空就可以倒水,同时接水的不能为满
Node v = new Node(-1, -1, -1, u.t+1);//下一状态 -1表达还没初始化
if(u.s > a - u.a) {//如果s里面的水大于a还能装的情况
v.s = u.s - (a - u.a);
v.a = a;
v.b = u.b;
}else {//就是能完全装的下的情况了
v.s = 0;
v.a = u.s + u.a;
v.b = u.b;
}
//				System.out.println(v.a+" "+v.b);//debug用的
if(!vis[v.a][v.b]) {
vis[v.a][v.b] = true;
q.add(v);
}

}

//s->b 同理
if(u.s!=0 && u.b!=b) {
Node v = new Node(-1, -1, -1, u.t+1);//下一状态 -1表达还没初始化
if(u.s > b - u.b) {
v.s = u.s - (b - u.b);
v.b = b;
v.a = u.a;
}else {
v.s = 0;
v.b = u.s + u.b;
v.a = u.a;
}
if(!vis[v.a][v.b]) {
vis[v.a][v.b] = true;
q.add(v);
}

}

//a->s 同理
if(u.a!=0 && u.s!=s) {
Node v = new Node(-1, -1, -1, u.t+1);//下一状态 -1表达还没初始化
if(u.a > s - u.s) {
v.a = u.a - (s - u.s);
v.s = s;
v.b = u.b;
}else {
v.a = 0;
v.s = u.a + u.s;
v.b = u.b;
}
if(!vis[v.a][v.b]) {
vis[v.a][v.b] = true;
q.add(v);
}

}

//a->b 同理
if(u.a!=0 && u.b!=b) {
Node v = new Node(-1, -1, -1, u.t+1);//下一状态 -1表达还没初始化
if(u.a > b - u.b) {
v.a = u.a - (b - u.b);
v.b = b;
v.s = u.s;
}else {
v.a = 0;
v.b = u.a + u.b;
v.s = u.s;
}
if(!vis[v.a][v.b]) {
vis[v.a][v.b] = true;
q.add(v);
}

}

//b->s 同理
if(u.b!=0 && u.s!=s) {
Node v = new Node(-1, -1, -1, u.t+1);//下一状态 -1表达还没初始化
if(u.b > s - u.s) {
v.b = u.b - (s - u.s);
v.s = s;
v.a = u.a;
}else {
v.b = 0;
v.s = u.b + u.s;
v.a = u.a;
}
if(!vis[v.a][v.b]) {
vis[v.a][v.b] = true;
q.add(v);
}

}

//b->a 同理
if(u.b!=0 && u.a!=a) {
Node v = new Node(-1, -1, -1, u.t+1);//下一状态 -1表达还没初始化
if(u.b > a - u.a) {
v.b = u.b - (a - u.a);
v.a = a;
v.s = u.s;
}else {
v.b = 0;
v.a = u.b + u.a;
v.s = u.s;
}
if(!vis[v.a][v.b]) {
vis[v.a][v.b] = true;
q.add(v);
}

}

}
return -1;
}

}
``````

hdu2612

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

public class hdu2612 {

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()) {
n = in.nextInt();
m = in.nextInt();
int x1 = 0,y1 = 0,x2 = 0,y2 = 0,ans = Integer.MAX_VALUE-5;
ch = new char[n][m];
vis = new boolean[n][m];
dis = new int[2][n][m];

for(int i=0;i<n;i++)
ch[i] = in.next().toCharArray();

for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(ch[i][j]=='Y') {
x1 = i;
y1 = j;
} else if(ch[i][j]=='M') {
x2 = i;
y2 = j;
}
for(int i=0;i<n;i++)
for(int j=0;j<m;j++) {
dis[0][i][j]=1000000;//吃到苦头了，不初始步长INF一直WA,原因是KFC可能被几个#包围，org
dis[1][i][j]=1000000;
}

bfs(0,x1,y1);
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
vis[i][j] = false;
bfs(1,x2,y2);
//			for(int i=0;i<n;i++) {
//				for(int j=0;j<m;j++) {
//					System.out.print(dis[0][i][j]+dis[1][i][j]+" ");
//				}
//				System.out.println();
//			}
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(ch[i][j]=='@' && dis[0][i][j]+dis[1][i][j]<ans)
ans = dis[0][i][j]+dis[1][i][j];
System.out.println(ans);

}
}

static int n,m;
static boolean[][] vis;
static int[][][] dis;
static char[][] ch;
static int[] dx = new int[] {1,0,-1,0};
static int[] dy = new int[] {0,1,0,-1};

static void bfs(int who,int x,int y) {
Node node = new Node(x, y, 0);
vis[x][y] = true;
Queue<Node> q = new LinkedList<>();
q.add(node);

while(!q.isEmpty()) {
Node u = q.poll();
dis[who][u.x][u.y] = u.t;
for(int i=0;i<4;i++)
if(u.x+dx[i]>=0 && u.x+dx[i]<n && u.y+dy[i]>=0 && u.y+dy[i]<m && ch[u.x+dx[i]][u.y+dy[i]]!='#' && !vis[u.x+dx[i]][u.y+dy[i]]) {
q.add(new Node(u.x+dx[i], u.y+dy[i], u.t+11));
vis[u.x+dx[i]][u.y+dy[i]] = true;
}
}

}

static class Node {
int x,y,t;
public Node(int x,int y,int t) {
this.x = x;
this.y = y;
this.t = t;
}
}

}
``````

0条评论