P2802 回家——DFS一键解决

题目描述

小H在一个划分成了n*m个方格的长方形封锁线上。 每次他能向上下左右四个方向移动一格（当然小H不可以静止不动）， 但不能离开封锁线，否则就被打死了。 刚开始时他有满血6点，每移动一格他要消耗1点血量。一旦小H的 血量降到 0， 他将死去。 他可以沿路通过拾取鼠标（什么鬼。。。）来补满血量。只要他走到有鼠标的格子，他不需要任何时间即可拾取。格子上的鼠标可以瞬间补满，所以每次经过这个格子都有鼠标。就算到了某个有鼠标的格子才死去， 他也不能通过拾取鼠标补满 HP。 即使在家门口死去， 他也不能算完成任务回到家中。

地图上有 5 种格子：

数字 0： 障碍物。

数字 1： 空地， 小H可以自由行走。

数字 2： 小H出发点， 也是一片空地。

数字 3： 小H的家。

数字 4： 有鼠标在上面的空地。

小H能否安全回家？如果能， 最短需要多长时间呢？

输入格式

第一行两个整数n,m， 表示地图的大小为n*m。

下面 n 行， 每行 m 个数字来描述地图。

输出格式

一行， 若小H不能回家， 输出-1,否则输出他回家所需最短时间。

输入输出样例

输入 #1复制

3 3
2 1 1
1 1 0
1 1 3

输出 #1复制

4

说明/提示

1<=n,m<=9

一见到迷宫我们就不由得想到DFS

因为递归用起来真的太爽了

你只需要设定好对应情况所需要做出的反应，然后一键DFS

答案就迎刃而解了！！！

（注意：DFS的灵魂就在于你的试探＋复原，就如同漫威里奇异博士几千次的预约，每当你开启一种可能，你就要提前做好还原的准备）

ps：这里筑墙是为了限定边界，主要为了试探过程中防止出现数组越界的情况

package 算法;

import java.io.*;

public class P2802_回家 {
    static StreamTokenizer r = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter pr = new PrintWriter(new OutputStreamWriter(System.out));
    static BufferedReader re = new BufferedReader(new InputStreamReader(System.in));
    static int heart = 6;
    static int ii;
    static int jj;
    static int leastPATH = 81;
    static int path = 0;
    static int n;
    static int m;


    public static void main(String[] args) throws IOException {
        r.nextToken();
        n = (int) r.nval;
        r.nextToken();
        m = (int) r.nval;
        int wall[][] = new int[n + 2][m + 2];

        for (int i = 1; i < n + 1; i++) {
            for (int j = 1; j < m + 1; j++) {
                r.nextToken();
                wall[i][j] = (int) r.nval;
                if (wall[i][j] == 2) {
                    ii = i;
                    jj = j;
                }
            }
        }

        //建墙
        for (int i = 0; i < n + 2; i++) {
            wall[i][0] = -1;
            wall[i][m + 1] = -1;
        }
        for (int i = 0; i < m + 2; i++) {
            wall[0][i] = -1;
            wall[n + 1][i] = -1;
        }
        goHome(wall, ii, jj);
        if (leastPATH != 81) {
            pr.println(leastPATH);
            pr.flush();
        } else {
            pr.println(-1);
            pr.flush();
        }

    }

    static void goHome(int a[][], int i, int j) {
        int head = a[i - 1][j];
        int bottom = a[i + 1][j];
        int left = a[i][j - 1];
        int right = a[i][j + 1];
        //试探+复原
        choiceNumber(head, a, i - 1, j);heart++; path--;
        choiceNumber(bottom, a, i + 1, j);heart++; path--;
        choiceNumber(left, a, i, j - 1);heart++; path--;
        choiceNumber(right, a, i, j + 1);heart++; path--;

        return;
    }

    static void choiceNumber(int a, int e[][], int i, int j) {
        path++;
        heart--;
        if(heart<=0||path>m*n||path>leastPATH){
            return;//及时回溯+防止溢栈
        }
        if (a == 0 || a == 2 || a == -1) {
               return;
        } else if (a == 1) {
            goHome(e, i, j);
        } else if (a == 3) {
             leastPATH = leastPATH < path ? leastPATH : path;
        } else {
            int tempheart=heart;
            heart = 6;
            goHome(e, i, j);
            heart=tempheart;//此处注意返回时要将血量复原
            
        }
    }
}