蓝桥杯 2014年 第五届 迷宫寻宝 详解(JAVA)
基础思路（DFS）
package provincial_2014B;
import java.util.Scanner;
/**
* 该题有两种做法：
* - dfs + 剪枝： 虽有优化，但还是速度较慢，但好入门
* - 动态规划（记忆性深搜实现）：先搞清楚dfs，再了解dp
*
*/
public class Nine {
// 一般都把map数组定义为全局变量
private static int n,m,k;
private static int[][] map;
private static final int MOD = 1000000007;
// 题中告知要对MOD取余，显然较大，所以用long或double
private static long ans;
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
n = scan.nextInt();
m = scan.nextInt();
k = scan.nextInt();
map = new int[n][m];
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++) {
map[i][j] = scan.nextInt();
}
}
dfs(0, 0, 0, -1);
System.out.println(ans);
}
// 需要注意的是：x是横坐标，y是纵坐标，所以对应于数组的元素为map[y][x];
private static void dfs(int x, int y, int goods, int max) {
// 边界预防
if(x==m||y==n) {
return;
}
int now = map[y][x];
// 到达最终点
// ***注意：到达最终点后由于不会再进行判断拿不拿了
// *** 所以必须在这里再判断一次拿不拿
if(x==m-1&&y==n-1) {
if(goods==k || (goods==k-1&&max<now)) {
ans++;
ans %= MOD;
}
return;
}
// 拿了，向下或向右走
if(max<now) {
dfs(x, y+1, goods+1, now);
dfs(x+1, y, goods+1, now);
}
// 没拿，向下或向右走
dfs(x+1, y, goods, max);
dfs(x, y+1, goods, max);
}
}
基础思路优化（剪枝）
当goods（已拿的宝物）比最终要拿到的宝物还多时，就return（不走了）。
package provincial_2014B;
import java.util.Scanner;
/**
* 该题有两种做法：
* - dfs + 剪枝： 虽有优化，但还是速度较慢，但好入门
* - 动态规划（记忆性深搜实现）：先搞清楚dfs，再了解dp
*
*/
public class Nine {
// 一般都把map数组定义为全局变量
private static int n,m,k;
private static int[][] map;
private static final int MOD = 1000000007;
private static long ans;
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
n = scan.nextInt();
m = scan.nextInt();
k = scan.nextInt();
map = new int[n][m];
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++) {
map[i][j] = scan.nextInt();
}
}
dfs(0, 0, 0, -1);
System.out.println(ans);
}
// 需要注意的是：x是横坐标，y是纵坐标，所以对应于数组的元素为map[y][x];
private static void dfs(int x, int y, int goods, int max) {
// 边界预防
if(x==m||y==n||goods>k) {
return;
}
int now = map[y][x];
// 到达最终点
// ***注意：到达最终点后由于不会再进行判断拿不拿了
// *** 所以必须在这里再判断一次拿不拿
if(x==m-1&&y==n-1) {
if(goods==k || (goods==k-1&&max<now)) {
ans++;
ans %= MOD;
}
return;
}
// 拿了，向下或向右走
if(max<now) {
dfs(x, y+1, goods+1, now);
dfs(x+1, y, goods+1, now);
}
// 没拿，向下或向右走
dfs(x+1, y, goods, max);
dfs(x, y+1, goods, max);
}
}
动态规划/记忆型递归
其实记忆型递归就是在刚刚剪枝的基础上再进行优化（剪枝）。
核心就是加入一个新数组cache用来缓存每一个子问题的解。其中，dfs有几个参数，cache就有几个维度。将每种情况看作一种状态。
package provincial_2014B;
import java.util.Scanner;
/**
* 该题有两种做法：
* - dfs + 剪枝： 虽有优化，但还是速度较慢，但好入门
* - 动态规划（记忆性深搜实现）：先搞清楚dfs，再了解dp
*
*/
public class Nine {
// 一般都把map数组定义为全局变量
private static int n,m,k;
private static int[][] map;
private static final int MOD = 1000000007;
// 开个数组反映一一映射关系
private static long[][][][] cache;
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
n = scan.nextInt();
m = scan.nextInt();
k = scan.nextInt();
map = new int[n][m];
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++) {
map[i][j] = scan.nextInt();
}
}
//***注意：因为宝物的价值一开始传进去为-1，不满足下标规则
//*** 所以记录时要+1，所以最大下标也要+1
cache = new long[n][m][14][14];
// 为什么填充-1：因为ans有可能return0，在不满足条件时，
// 就可以看做该点已经走过，状态为0
for(int i = 0; i < n; i++)
for(int j = 0; j < m; j++)
for(int r = 0; r < 14; r++)
for(int q = 0; q < 14; q++)
cache[i][j][r][q]=-1;
long ans = dp(0, 0, 0, -1);
System.out.println(ans);
}
private static long dp(int x, int y, int goods, int max) {
// 边界预防+剪枝
if(x==m||y==n||goods>k) {
return 0;
}
if(cache[y][x][goods][max+1]!=-1) return cache[y][x][goods][max+1];
int now = map[y][x];
// 某个点的返回值（该点的状态/该点拿了几件货物）
// 由以下情况组成
long ans = 0;
// 到达最终点
// ***注意：到达最终点后由于不会再进行判断拿不拿了
// *** 所以必须在这里再判断一次拿不拿
if(x==m-1&&y==n-1) {
if(goods==k || (goods==k-1&&max<now)) {
return 1;
}
return 0;
}
// 拿了，向下或向右走
if(max<now) {
ans += dp(x, y+1, goods+1, now);
ans += dp(x+1, y, goods+1, now);
}
// 没拿，向下或向右走
ans += dp(x+1, y, goods, max);
ans += dp(x, y+1, goods, max);
// 记录该点的值到缓存
cache[y][x][goods][max+1] = ans % MOD;
return cache[y][x][goods][max+1];
}
}