Java 地下迷宫·算法·(ACM/蓝桥杯)·递归解法

题目：

小青蛙有一天不小心落入了一个地下迷宫,小青蛙希望用自己仅剩的体力值P跳出这个地下迷宫。为了让问题简单,假设这是一个n*m的格子迷宫,迷宫每个位置为0或者1,0代表这个位置有障碍物,小青蛙达到不了这个位置;1代表小青蛙可以达到的位置。小青蛙初始在(0,0)位置,地下迷宫的出口在(0,m-1)(保证这两个位置都是1,并且保证一定有起点到终点可达的路径),小青蛙在迷宫中水平移动一个单位距离需要消耗1点体力值,向上爬一个单位距离需要消耗3个单位的体力值,向下移动不消耗体力值,当小青蛙的体力值等于0的时候还没有到达出口,小青蛙将无法逃离迷宫。现在需要你帮助小青蛙计算出能否用仅剩的体力值跳出迷宫(即达到(0,m-1)位置)。
输入描述:

输入包括n+1行:

第一行为三个整数n,m(3 <= m,n <= 10),P(1 <= P <= 100)

接下来的n行:

每行m个0或者1,以空格分隔

输出描述:

如果能逃离迷宫,则输出一行体力消耗最小的路径,输出格式见样例所示;如果不能逃离迷宫,则输出”Can not escape!”。
测试数据保证答案唯一

输入例子:

4 4 10
1 0 0 1
1 1 0 1
0 1 1 1
0 0 1 1

输出例子:

[0,0],[1,0],[1,1],[2,1],[2,2],[2,3],[1,3],[0,3]

BFS最短路径，并且记录路径。

解题思路：

采用递归的方法分别像上下左右四个方向找出口，找到出口以后与上一条比较是否为更省能量的一条路径，如果是，就更新路径，如果不是，就继续递归。

编码前提示：

请先思考明白再写，否则真的没啥效果。

import java.util.*;
 
public class Test {
 
    static int n = 0, m = 0, maxEnergy = 0;
    static int[][] map ;
    static boolean flag = false;
    static String path = "";
    static LinkedList l = new LinkedList<>();
 
    public static void main(String[] args) {
        int p ;
        Scanner s = new Scanner(System.in);
        if (s.hasNext()) {
            n = s.nextInt();
            m = s.nextInt();
            p = s.nextInt();
            map = new int[n][m];
 
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    map[i][j] = s.nextInt();
                }
            }
 
            runMap(0, 0, p);
 
            if (flag) {
                System.out.println(path);
            } else {
                System.out.println("Can not escape");
            }
        }
    }
 
    /**
     * 更新路径
     */
    public static void updataPath()
    {
        StringBuffer sb = new StringBuffer();
        Iterator i = l.iterator();
        while(i.hasNext())
        {
            sb.append(i.next()+',');
        }
        if (sb.length() > 0)
        {
            sb.deleteCharAt(sb.length()-1);
        }
        path = sb.toString();
    }
 
    /**
     * 走迷宫
     * @param x  行
     * @param y  列
     * @param energy  能量
     */
    public static void runMap(int x, int y, int energy)
    {
        //如果边界越界或者能量消耗完或者此路不通的时候
        if (x<0 || y<0 || x>=m || y>=n || energy<0 || map[x][y] != 1)
        {
            return;
        }
        //此路可以走
        else
        {
            map[x][y] = 2;
            l.offer("["+x+","+y+"]");
 
            if (x==0 && y==m-1)//到达出口
            {
                /**
                 * 到出口要干的事：
                 *     判断是不是最省能量的路径-->如果不是，更新路径；如果是,退出递归，打印路径
                 */
                if (energy >= maxEnergy)//消耗的能量越少，剩下的能量就越多，如果这次剩下了更多的能量，就说明这一条路消耗更少的能量，就更新路径
                {
                    maxEnergy = energy;
                    updataPath();
                }
                //跟新完路径之后，将此处之前该过的值改回去，在沿着之前的路径朝回走
                map[x][y] = 1;
                l.removeLast();
                flag = true;
                return ;
            }
        }
        //往上走
        runMap(x-1, y, energy-3);
        //往右走
        runMap(x, y+1, energy-1);
        //往下走
        runMap(x+1, y, energy);
        //往左走
        runMap(x, y-1, energy-1);
        //如果往上下左右四个方向都走不通，就沿原路返回，到上一个节点处在看能不能往其他方向走
        map[x][y] = 1;
        l.removeLast();
    }
}

祝你在大学的时候能获得一个国家级的算法比赛的国二级别以上的成绩，这将是你一生的财富。