迷宫问题(java)

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
[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);
}
}