题目描述

　　有一个N*M大小的迷宫矩阵，迷宫中的每个各自都有一个数值（R<10^9）。小猿在迷宫中发现，他只能朝着上下左右四个方向的相邻格子前进，并且只能进入比当前位置数值更大的格子。但是小猿有个紧急呼救按钮，它可以通过按下按钮，强行进入到不满足书纸大小要求的相邻格子，可惜这个按钮只能使用K次，请问小猿从这个迷宫任选一个格子出发，在紧急呼救按钮的帮助下，最多能走多少步？（开始位置计入步数，即站在起点是步数为1）。

输入描述

　　第一行输入 N,M,K, 接下来N行，每行M个数，表示每个迷宫中各个格子的值。

　　1<= N <= 500

　　1<= M <= 500　

　　0<= K <= 10

输入
3 3 1
1 3 3
2 4 9
8 9 2

输出
6

说明

其中一种方案：（0,0）->（0,1）->（0,0）->（1,0）->（2,0）->（2,1）

分析

　　DP动态规划+DFS(深度优先搜索)

1. 如果dp[x][y][k]不等于初始值的时候直接返回就可以了（dp[i][j][k]代表从i,j出发用k次机会最远的距离）
2. 开始位置计入步数，即站在起点是步数为1
3. 朝着上下左右四个方向的相邻格子前进，当前位置的最多能走步数 = max(当前位置的最多能走步数,相邻位置的最多能走步数+1)
   • 越界的话，无视并继续下一个
   • 只能进入比当前位置数值更大的格子
   • 通过按下按钮，强行进入到不满足书纸大小要求的相邻格子(k-1)，可惜这个按钮只能使用K次

    if(mat[x][y] < mat[nx][ny])  dp[x][y][k] = Math.max(dp[x][y][k], dfs(nx, ny, k) + 1);
    if(mat[x][y] >= mat[nx][ny] && k > 0) dp[x][y][k] = Math.max(dp[x][y][k], dfs(nx, ny, k - 1) + 1);  

4. 返回单个dp[i][j][k]代表从i,j出发用k次机会最远的距离
5. 任选一个格子出发，在紧急呼救按钮的帮助下，最多能走多少步（所有的最大值）

代码

import java.util.Scanner;

public class Main {
    private static int dx[] = {0, 1, 0, -1};//用于迷宫的上下左右移动
    private static int dy[] = {1, 0, -1, 0};//用于迷宫的上下左右移动
    private static int N;//迷宫的行
    private static int M;//迷宫的列
    private static int K;//可以‘强行进入到不满足书纸大小要求的相邻格子‘的次数
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        M = sc.nextInt();
        K = sc.nextInt();
        sc.nextLine();
        int [][] mat = new int[N][M];//迷宫的每个格子的数值
        for (int i = 0; i < N; i++) {
            String[] str = sc.nextLine().split(" ");
            for (int j = 0; j < M; j++) {
                mat[i][j] = Integer.valueOf(str[j]);
            }
        }
        int [][][] dp = new int[N][M][K+1];    //dp[i][j][k]代表从i,j出发用k次机会最远的距离
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                for (int k = 0; k <= K; k++) {
                    dp[i][j][k] = -1;//初始化
                }
            }
        }
        int maxresult = 0;　　　　　//任选一个格子出发，在紧急呼救按钮的帮助下，最多能走多少步
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                dp[i][j][K] = dfs(i, j, K, dp, mat);
                maxresult = Math.max(maxresult, dp[i][j][K]); //所有结果的最大值
            }
        }
        System.out.println(maxresult);
    }

    /**
     * DFS--DP动态规划
     * 一个记忆化搜索
     * 代表从 当前位置(x,y)出发用k次机会最多能走步数
     * @param x    当前位置(x,y)
     * @param y    当前位置(x,y)
     * @param k    用k次机会
     * @param dp dp[i][j][k]代表从i,j出发用k次机会最远的距离
     * @param mat    迷宫的每个格子的数值
     * @return
     */
    public static int dfs(int x, int y, int k, int[][][]dp,int[][]mat) {
        /**如果dp[x][y][k]不等于初始值的时候直接返回就可以了*/
        if(dp[x][y][k] != -1)
            return dp[x][y][k];
        /**开始位置计入步数，即站在起点是步数为1*/
        dp[x][y][k] = 1;
        /**朝着上下左右四个方向的相邻格子前进*/
        /** 当前位置的最多能走步数 = max(当前位置的最多能走步数,相邻位置的最多能走步数+1) **/
        for(int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            /**越界的话，无视并继续下一个**/
            if(nx < 0 || nx >= N || ny < 0 || ny >= M)
                continue;
            /**只能进入比当前位置数值更大的格子*/
            if(mat[x][y] < mat[nx][ny])
                dp[x][y][k] = Math.max(dp[x][y][k], dfs(nx, ny, k, dp, mat) + 1);
            /**通过按下按钮，强行进入到不满足书纸大小要求的相邻格子(k-1)，可惜这个按钮只能使用K次*/
            if(mat[x][y] >= mat[nx][ny] && k > 0)
                dp[x][y][k] = Math.max(dp[x][y][k], dfs(nx, ny, k - 1, dp, mat) + 1);
        }
        /**代表从 当前位置(x,y)出发用k次机会最多能走步数*/
        return dp[x][y][k];
    }
}

原文地址：https://www.cnblogs.com/haimishasha/p/11305133.html