c++和Java dfs迷宫问题

1.按照右下左上这个顺时针顺序走

2.全局变量中的迷宫是100*100，就已经把迷宫初始化全为0

3.迷宫要使用的大小是5*4，只有这块区域路和障碍物

如果迷宫直接定义大小5*4，没有把初始地图扩大，会导致数组越界

假设走到边界时，如果地图和为4列，按照循环和走路顺序，下一次必定向右判断，判断第5列，但是地图就定义4列，无法判断第5列，这就导致数组越界

0 0 0 0 0 0 0

0 1 1 2 1 0 0 

0 1 1 1 1 0 0

0 1 1 2 1 0 0

0 1 2 1 1 0 0

0 1 1 1 2 0 0

0 0 0 0 0 0 0

4.for循环中，它是先判断“右”位置能不能走，判断能走就走，走了之后就是dfs，再一次for循环还是以k=0开始向右走；不能走就来一次for循环让k+1判断“下”方向位置能不能走，依次这样判断

5.dfs里面的if中的return，是会回到v[tx][ty]=0这步开始回溯，找其他路径，第一次找到路径为7，开始回溯找其他最短路径，找到就更新，按照上面迷宫，最短路径为7，但是路径不唯一

/*
一个n行m列单元格迷宫，每个格子要么空地要么就是障碍物
 给定起点和终点，求最短路径 
*/ 
/*	     x-1,y上 
x,y-1左    x,y  	x,y+1右 
	     x+1,y下 
		 
5 4     //迷宫大小
1 1 2 1  //迷宫内的路和障碍物
1 1 1 1
1 1 2 1
1 2 1 1
1 1 1 2

1 1 4 3 //起始点 和 终点 
输出7 
*/ 
#include<cstdio>
#include<iostream>
using namespace std;
int p,q;//pq是终点坐标，min是最短路径
int MIN = 99999;
int m,n;//迷宫大小 
int dx[4] = {0,1,0,-1};
int dy[4] = {1,0,-1,0}; //dx，dy两个表示上下左右 
int a[100][100];//迷宫，1表示空地，2表示障碍物 
int v[100][100];//判断是否访问，0未访问，1访问 
//xy是坐标，step是经过的步数
void dfs(int x , int y , int step){
	//终点情况 
	if(x == p && y == q){
		if(step < MIN){
			MIN = step;
		}
		return; 
	} 
	
	for(int k = 0 ; k <= 3 ; k++){ // <=3循环的是4个方向 
		 int tx,ty;//表示下一个方向
		 tx = x + dx[k];
		 ty = y + dy[k];//这两个是有当前位置去加减得出下一个坐标 
		 if(a[tx][ty] == 1 && v[tx][ty] == 0 ){
		 	v[tx][ty] = 1;
		 	dfs(tx,ty,step+1);
		 	v[tx][ty] = 0;
		 } 
	} 
	return;
	//不是终点顺时针试探前面是否有路 
	/* 没有优化四个方向 
	//右
	if(a[x][y+1] == 1 && v[x][y+1] == 0){
		v[x][y+1] = 1; //当前已经访问 
		dfs(x,y+1,step+1);//使用dfs向右搜索，步数+1 
		v[x][y+1] = 0;//dfs执行完要回退，相当于还没访问如同时间倒退到没访问时候 
	}
	//下
	if(a[x+1][y] == 1 && v[x+1][y] == 0){
		v[x+1][y] = 1;
		dfs(x+1,y,step+1);
		v[x+1][y] = 0;
	} 
	//左
	if(a[x][y-1] == 1 && v[x][y-1] == 0){
		v[x][y-1] = 1;  
		dfs(x,y-1,step+1);
		v[x][y-1] = 0;
	}	 
	// 上 
	if(a[x-1][y] == 1 && v[x-1][y] == 0){
		v[x-1][y] = 1;
		dfs(x-1,y,step+1);
		v[x-1][y] = 0;
	} 
	*/	
	//return;	
}
int main(){
	int startx,starty;//起始点 
	cin>>m >> n;
	for(int i = 1 ; i <= m ; i++){
		for(int j = 1 ; j <= n ; j++){
			cin>>a[i][j]; //1表示空地，2表示障碍物 
		}
	} 
	cin>>startx>>starty>>p>>q; 
	v[startx][starty] = 1;//起点是已经访问的 
	dfs(startx,starty,0);//起始步数，因为没动所以起始为0步 
	cout << MIN; 
	
}

import java.util.Arrays;
import java.util.Scanner;

public class test {
    static int p=4,q=3,m=5,n=4;
    static int[] dx = new int[]{0,1,0,-1};
    static int[] dy = new int[]{1,0,-1,0};
    static int min = 999;
    static int[][] a = new int[100][100];
    static int[][] v = new int[100][100];

        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            for (int i = 1; i <= m; i++) {
                for (int j = 1; j <=n ; j++) {
                    a[i][j] = scanner.nextInt();
                }
            }
            v[1][1] = 1;
            dfs(1,1,0);
            System.out.println(min);
    }

    private static void dfs(int x, int y, int step) {
            if(x == p && y == q){
                if(step < min){
                    min = step;
                }
                return;
            }
        for (int k = 0; k <=3 ; k++) {
            int tx , ty;
            tx= x + dx[k];
            ty= y + dy[k];

            if(a[tx][ty] == 1 && v[tx][ty] == 0){
                v[tx][ty] = 1;
                dfs(tx,ty,step+1);
                v[tx][ty] = 0;
            }
        }
        return;
    }
}