关于Java的走迷宫问题

题目是这样的：
用户输入一个值，生成一个n*n的矩阵，然后每个符号之间用空格隔开，要求从A到B，如果当前位置的坐标是“+”那么下一个坐标则必须为“-”，找出最短的路径的步数

我的代码是把所有的情况写出来，但是出错了，请各位大神看看哪里有问题

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

//矩阵的大小
static int n;
//用于记录是否走到了终点，true表示到了，false表示没有到，默认false
static boolean flag = false;
//用于存放所有的结果
static ArrayList<Integer> list = new ArrayList<Integer>();

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    n = sc.nextInt();
    sc.nextLine();

    String[][] map = Produce();

    //测试代码
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            System.out.print(map[i][j]);
        }
        System.out.println();
    }

    //得到"A"的坐标，"B"的坐标
    int[] a = Local(map, "A");
    int[] b = Local(map, "B");

    //测试坐标是否正确
    System.out.println(a[0] + "   " + a[1]);
    System.out.println(b[0] + "   " + b[1]);

    //开始移动
    Move(map, a, b, 0);

    System.out.println("=========================");
    for(int i = 0; i < list.size(); i++){
        System.out.println(list.get(i));
    }

    System.out.println("end！");
}

private static void Move(String[][] m, int[] a, int[] b, int s) {
    //用于记录走过的步数
    int sum = s;        
    String[][] map = m;
    //表示当前坐标
    int[] local = a;
    //表示终点坐标
    int[] end = b;

    MoveUp(map, local, end, sum);
    System.out.println(flag);
    //判断上一步是否到达了终点
    if(flag){
        //加入List集合，然后初始化，接着其他方案
        list.add(sum+1);
        flag = false;
    }

    //重新赋值
    sum = s;        
    map = m;
    local = a;
    end = b;            
    MoveRight(map, local, end, sum);
    System.out.println(flag);
    if(flag){
        //加入List集合，然后初始化，接着其他方案
        list.add(sum+1);
        flag = false;
    }

    //重新赋值
    sum = s;        
    map = m;
    local = a;
    end = b;
    MoveDown(map, local, end, sum);
    System.out.println(flag);
    if(flag){
        //加入List集合，然后初始化，接着其他方案
        list.add(sum+1);
        flag = false;
    }

    //重新赋值
    sum = s;        
    map = m;
    local = a;
    end = b;
    MoveLeft(map, local, end, sum);
    System.out.println(flag);
    if(flag){
        //加入List集合，然后初始化，接着其他方案
        list.add(sum+1);
        flag = false;
    }

}

private static void MoveLeft(String[][] map, int[] local, int[] end, int sum) {

// //重新定义，用于保护现场，避免下一次走错
// String[][] map = m;
// int[] local = a;
// int[] end = b;
// int sum = s;

    //首先判断当前的坐标能不能向左移动
    if(local[1] != 0){
        //判断是否到了终点
        if((local[0] == end[0]) && (local[1]-1 == end[1])){
            //设置到达了终点
            flag = true;
            return;
        }
        else{
            if(map[local[0]][local[1]].equals("A")){
                //把当前位置置为空，避免下一次重复走
                map[local[0]][local[1]] = " ";
                //改变坐标
                local[1]--;
                sum++;//步数加1
                //调用Move函数，接着往下走
                Move(map, local, end, sum);
            }
            else if(map[local[0]][local[1]].equals("+") && 
                    map[local[0]][local[1]-1].equals("-")){
                //把当前位置置为空，避免下一次重复走
                map[local[0]][local[1]] = " ";
                //改变坐标
                local[1]--;
                sum++;//步数加1
                //调用Move函数，接着往下走
                Move(map, local, end, sum);
            }
            else if(map[local[0]][local[1]].equals("-") && 
                    map[local[0]][local[1]-1].equals("+")){
                //把当前位置置为空，避免下一次重复走
                map[local[0]][local[1]] = " ";
                //改变坐标
                local[1]--;
                sum++;//步数加1
                //调用Move函数，接着往下走
                Move(map, local, end, sum);
            }
        }
    }

}

private static void MoveDown(String[][] map, int[] local, int[] end, int sum) {

// //重新定义，用于保护现场，避免下一次走错
// String[][] map = m;
// int[] local = a;
// int[] end = b;
// int sum = s;

    //首先判断当前的坐标能不能向下移动
    if(local[0] != n-1){
        //判断是否到了终点
        if((local[0]+1 == end[0]) && (local[1] == end[1])){
            //设置到达了终点
            flag = true;
            return;
        }
        else{
            if(map[local[0]][local[1]].equals("A")){
                //把当前位置置为空，避免下一次重复走
                map[local[0]][local[1]] = " ";
                //改变坐标
                local[0]++;
                sum++;//步数加1
                //调用Move函数，接着往下走
                Move(map, local, end, sum);
            }
            else if(map[local[0]][local[1]].equals("+") && 
                    map[local[0]+1][local[1]].equals("-")){
                //把当前位置置为空，避免下一次重复走
                map[local[0]][local[1]] = " ";
                //改变坐标
                local[0]++;
                sum++;//步数加1
                //调用Move函数，接着往下走
                Move(map, local, end, sum);
            }
            else if(map[local[0]][local[1]].equals("-") && 
                    map[local[0]+1][local[1]].equals("+")){
                //把当前位置置为空，避免下一次重复走
                map[local[0]][local[1]] = " ";
                //改变坐标
                local[0]++;
                sum++;//步数加1
                //调用Move函数，接着往下走
                Move(map, local, end, sum);
            }
        }
    }

}

private static void MoveRight(String[][] map, int[] local, int[] end, int sum) {

// //重新定义，用于保护现场，避免下一次走错
// String[][] map = m;
// int[] local = a;
// int[] end = b;
// int sum = s;

    //首先判断当前的坐标能不能向右移动
    if(local[1] != n-1){
        //判断是否到了终点
        if((local[0] == end[0]) && (local[1]+1 == end[1])){
            //设置到达了终点
            flag = true;
            return;
        }
        else{
            if(map[local[0]][local[1]].equals("A")){
                map[local[0]][local[1]] = " ";
                //改变坐标
                local[1]++;
                sum++;//步数加1
                //调用Move函数，接着往下走
                Move(map, local, end, sum);
            }
            else if(map[local[0]][local[1]].equals("+") && 
                    map[local[0]][local[1]+1].equals("-")){
                //把当前位置置为空，避免下一次重复走
                map[local[0]][local[1]] = " ";
                //改变坐标
                local[1]++;
                sum++;//步数加1
                //调用Move函数，接着往下走
                Move(map, local, end, sum);
            }
            else if(map[local[0]][local[1]].equals("-") && 
                    map[local[0]][local[1]+1].equals("+")){
                //把当前位置置为空，避免下一次重复走
                map[local[0]][local[1]] = " ";
                //改变坐标
                local[1]++;
                sum++;//步数加1
                //调用Move函数，接着往下走
                Move(map, local, end, sum);
            }
        }
    }

}

private static void MoveUp(String[][] map, int[] local, int[] end, int sum) {

// //重新定义，用于保护现场，避免下一次走错
// String[][] map = m;
// int[] local = a;
// int[] end = b;
// int sum = s;

    //首先判断当前的坐标能不能向上移动
    if(local[0] != 0){
        //判断是否到了终点
        if((local[0]-1 == end[0]) && (local[1] == end[1])){
            //设置到达了终点
            flag = true;
            return;
        }
        else{
            if(map[local[0]][local[1]].equals("A")){
                //把当前位置置为空，避免下一次重复走
                map[local[0]][local[1]] = " ";
                //改变坐标
                local[0]--;
                sum++;//步数加1
                //调用Move函数，接着往下走
                Move(map, local, end, sum);
            }
            else if(map[local[0]][local[1]].equals("+") && 
                    map[local[0]-1][local[1]].equals("-")){
                //把当前位置置为空，避免下一次重复走
                map[local[0]][local[1]] = " ";
                //改变坐标
                local[0]--;
                sum++;//步数加1
                //调用Move函数，接着往下走
                Move(map, local, end, sum);
            }
            else if(map[local[0]][local[1]].equals("-") && 
                    map[local[0]-1][local[1]].equals("+")){
                //把当前位置置为空，避免下一次重复走
                map[local[0]][local[1]] = " ";
                //改变坐标
                local[0]--;
                sum++;//步数加1
                //调用Move函数，接着往下走
                Move(map, local, end, sum);
            }
        }
    }

}

//得到str的坐标
private static int[] Local(String[][] map, String str) {
    int[] local = new int[2];
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            if(map[i][j].equals(str)){
                local[0] = i;
                local[1] = j;
                return local;
            }
        }
    }

    return local;
}

//产生一个n*n的阵列
private static String[][] Produce(){
    Scanner sc = new Scanner(System.in);
    String[] m = new String[n];
    String[][] map = new String[n][n];

    //控制台输入
    for(int i = 0; i < n; i++){
        m[i] = sc.nextLine();
    }

    //对输入的数据进行转换成去掉空格的
    for(int i = 0; i < n; i++){
        map[i] = m[i].split(" ");
    }

    return map;
}

}

http://www.cnblogs.com/rollenholt/archive/2011/08/23/2151202.html