题目描述

有一个n*m的棋盘(1<n,m<=400)，在某个点上有一个马,要求你计算出马到达棋盘上任意一个点最少要走几步
输入格式

一行四个数据，棋盘的大小和马的坐标

输出格式

一个n*m的矩阵，代表马到达某个点最少要走几步（左对齐，宽5格，不能到达则输出-1）
输入输出样例
**输入 **

3 3 1 1

输出

0    3    2    
3    -1   1    
2    1    4    

思路
一看就是BFS,不是很难但是这是我第一道BFS的题，所以纪念一下。 这题求马到达棋盘上任意一个点最少要走几步，一共八个方向，所以我们可以先定义出方向数组

public static int xx[]={
    
    2,1,-1,-2,-2,-1,1,2};
public static int yy[]={
    
    1,2,2,1,-1,-2,-2,-1};	

然后就是一系列套路Java中队列这么定义
Queue<Integer> x=new LinkedList<Integer>();网上看到的 ，此外要注意的点
1.走不到的点要为-1,我们可以在初始化的时候把全部的点都变为-1,这样我们最后，就不再找一遍；
2，我们这一步的步数，是上一步的步数加1得来的，c++使用结构体记录上一步的步长，我们Java定义一个记录步数的二维数组记录步长会比较便捷，a[i][j]表示马走到第i行j列的最小步数；
3.就是输出的时候System.out.printf("%-5d",a[i][j]);这样才能和题目输出的格式一样
最后上代码

   import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class Main {
    
    
	   public static int xx[]={
    
    2,1,-1,-2,-2,-1,1,2};
	    public static int yy[]={
    
    1,2,2,1,-1,-2,-2,-1};
	    public static int temp[][]=new int[405][405];
	    public static int step[][]=new int [405][405];
	    public static void main(String[] args) {
    
    
	        Scanner input=new Scanner(System.in);
	        int n=input.nextInt();
	        int m=input.nextInt();
	        int sx=input.nextInt();
	        int sy=input.nextInt();
	        int a[][]=new int[n+1][m+1];
	        
	        for(int i=0;i<n+1;i++){
    
    
	            for(int j=0;j<m+1;j++){
    
    
	                a[i][j]=-1;
	            }
	        }
	        bfs(sx,sy,a,n,m);
	        for(int i=1;i<n+1;i++){
    
    
	            for(int j=1;j<m+1;j++){
    
    
	               System.out.printf("%-5d",a[i][j]);
	            }
	            System.out.println();
	        }


	    }
	    public static void bfs(int sx,int sy,int a[][],int n,int m){
    
    
	        Queue<Integer> x=new LinkedList<Integer>();
	        Queue<Integer> y=new LinkedList<Integer>();
	        
	        x.offer(sx);
	        y.offer(sy);
	        //第一个点初始化为0
	        a[sx][sy]=0;
	        //用来标记哪些点已经走过，走过了就不走了
	        temp[sx][sy]=1;
	        while(!x.isEmpty()&&!y.isEmpty()){
    
    
	             int x2=x.poll();
	             int y2=y.poll();
	             for(int i=0;i<8;i++){
    
    
	            	  int x1=x2+xx[i];
	  	              int y1=y2+yy[i];
	                  if((x1>=1&&x1<=n&&y1>=1&&y1<=m)&&temp[x1][y1]==0){
    
    
	                    temp[x1][y1]=1;
	                    a[x1][y1]=a[x2][y2]+1;//由x2,y2向其他八个方向走，一次上一步就是a[x2][y2];
	                    
	                    x.offer(x1);
	                    y.offer(y1);
	                }
	         }
	       }
          } 
   	    }