1、题目：

题目描述

小青蛙有一天不小心落入了一个地下迷宫,小青蛙希望用自己仅剩的体力值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!"。 测试数据保证答案唯一

示例1

输入

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]

2、思想：递归

开始一下想到动态规划了，一分析发现，这并不符合动态规划的思想，也就是dp[i][j]不能由dp[x][y](x<=i,y<=j)的表示，这是因为路径的选择是从四个方向都可以的，而不是从左上到右下的一个遍历过程。所以，想到的就是递归了。还是自己算法底子太弱，不能一下分析到问题的核心算法，唉…

3、code：

package schooloffer17;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Scanner;

/**
 * Created by caoxiaohong on 17/11/18 10:47.
 * <地下迷宫></>
 * 水平移动:消耗1个力量;
 * 向上移动:消耗3个力量;
 * 向下移动:不消耗体力;
 */
public class UndergroundLabyrinth {
    public static void main(String[] args) {
        int n,m,p;
        Scanner scanner=new Scanner(System.in);
        while (scanner.hasNextInt()){
            n=scanner.nextInt();
            m=scanner.nextInt();
            p=scanner.nextInt();
            int[][] lab=new int[n][m];
            for(int i=0;i<n;i++){
                for(int j=0;j<m;j++)
                    lab[i][j]=scanner.nextInt();
            }
            recursion(lab,n,m,p,0,0);
            if(isFind){
                System.out.println(sb.toString());
            }else{
                System.out.println("Can not escape!");
            }
        }
    }

    //递归
    static LinkedList<LinkedList<Integer>> path=new LinkedList<LinkedList<Integer>>();
    static boolean isFind=false;
    static int maxRemainPower=0;
    static StringBuilder sb=new StringBuilder();
    /**
     * 查找是否存在路径
     * @param map  迷宫布局情况
     * @param rows 迷宫行数
     * @param cols 迷宫列数
     * @param power 剩余能力
     * @param i 当前到达行号
     * @param j 当前到达列号
     */
    private static void recursion(int[][] map,int rows,int cols,int power,int i,int j){
        if(i<0 || i>=rows || j<0 || j>=cols || map[i][j]==0 || power<0)
            return;
        else{
            LinkedList<Integer> tmp=new LinkedList<Integer>();
            tmp.add(i);
            tmp.add(j);
            path.add(tmp);
            map[i][j]=0;//表示这个点不能再访问
            if(i==0 && j==cols-1){
                if(power>=maxRemainPower){//如果有更节省能量的路径,则路径被更新
                    maxRemainPower=power;
                    updatePath(path);
                }
                isFind=true;
                map[i][j]=1;
                path.removeLast();
                return;
            }
            //up
            recursion(map,rows,cols,power-3,i-1,j);
            //right
            recursion(map,rows,cols,power-1,i,j+1);
            //down
            recursion(map,rows,cols,power,i+1,j);
            //left
            recursion(map,rows,cols,power-1,i,j-1);
            map[i][j]=1;//回退到点(i,j),则恢复该点的原状态.
            path.removeLast();//删除节点(i,j)
        }
    }

    /**
     * 更新路径:保留最节省能量的走法
     * @param list 已经找到的一种路径走法.
     */
    private  static  void updatePath(LinkedList<LinkedList<Integer>> list){
        Iterator<LinkedList<Integer>> iterator=list.iterator();
        while (iterator.hasNext()){
            LinkedList<Integer> tmp=iterator.next();
            sb.append("["+tmp.get(0)+","+tmp.get(1)+"]"+",");
        }
        if(sb.length()>0)
            sb.deleteCharAt(sb.length()-1);
    }
}