bfs对应的数据结构是队列，采用队列的方式求解，同时对路径进行记录输出

不可以采用dp，在dp算法中如果规定了只能了向下和向右走的话，这样虽然避免了重复路径的走法，但是会导致路径不通

具体的实现！

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

class Pairxy{
    int x;
    int y;
    public Pairxy(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }

}


public class  Main  {

    static int N=110;
    static int n;
    static int m;
    static int a[][]=new int [N][N];
    static int step[][]=new int [N][N];
    //step数组表示到step[x][y]走的步数，没有访问过的点置为1
    static Pairxy[][] path=new Pairxy[N][N];

    public static int  bfs() {
        Queue<Pairxy> queue=new LinkedList<Pairxy>();
        queue.offer(new Pairxy(0, 0));
        //将首行元素放到队列中去
        step[0][0]=0;
        //step数组初始值为0，从(0,0)处走到的点步数为1，所以需要把step[0][0]初始化为0
        int dx[]={-1,1,0,0};
        int dy[]={0,0,-1,1};

        while(!queue.isEmpty()){
            Pairxy pairxy = queue.poll();


            for(int i=0;i<4;i++){

                int x=pairxy.x+dx[i];
                int y=pairxy.y+dy[i];
                if(x>=0 && x<n && y>=0 && y<m && step[x][y]==-1 && a[x][y]==0){
                    queue.offer(new Pairxy(x, y));
                    step[x][y]=1+step[pairxy.x][pairxy.y];
                    path[x][y]=pairxy;
                    //两句话的顺序没有什么影响
                }
            }
        }

    /*  int x=n-1;
        int y=m-1;
        while(x!=0 || y!=0){
            System.out.println(x+" "+y);
            Pairxy t=path[x][y];
            x=t.x;
            y=t.y;
        }*/

    //输出路径

        return step[n-1][m-1];

    }

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String p[]=bufferedReader.readLine().split(" ");
         n=Integer.parseInt(p[0]);
         m=Integer.parseInt(p[1]);
         a=new int [n][m];
        for(int i=0;i<n;i++){
            p=bufferedReader.readLine().split(" ");
            for(int j=0;j<m;j++){
                a[i][j]=Integer.parseInt(p[j]);
            }
        }

        for(int i=0;i<n;i++){
            Arrays.fill(step[i], -1);
            //没有到达过的点置为-1
        }

        System.out.println(bfs());

    }

}