蓝桥杯-地宫取宝

题目描述：

X 国王有一个地宫宝库。是 n x m 个格子的矩阵。每个格子放一件宝贝。每个宝贝贴着价值标签。
地宫的入口在左上角，出口在右下角。
小明被带到地宫的入口，国王要求他只能向右或向下行走。
走过某个格子时，如果那个格子中的宝贝价值比小明手中任意宝贝价值都大，小明就可以拿起它（当然，也可以不拿）。
当小明走到出口时，如果他手中的宝贝恰好是k件，则这些宝贝就可以送给小明。
请你帮小明算一算，在给定的局面下，他有多少种不同的行动方案能获得这k件宝贝。
【数据格式】
输入一行3个整数，用空格分开：n m k (1<=n,m<=50, 1<=k<=12)
接下来有 n 行数据，每行有 m 个整数 Ci (0<=Ci<=12)代表这个格子上的宝物的价值
要求输出一个整数，表示正好取k个宝贝的行动方案数。该数字可能很大，输出它对 1000000007 取模的结果。
例如，输入：
2 2 2
1 2
2 1
程序应该输出：
2
再例如，输入：
2 3 2
1 2 3
2 1 5
程序应该输出：
14
资源约定：
峰值内存消耗 < 256M

CPU消耗  < 1000ms

分析：这道题看到的第一反应就是搜索，但是直接搜索不剪枝的话肯定会超时，所以我们采用记忆化搜索。就是搜索和动态规划相结合的而形成的一种折中的方法。动态规划会遍历所有的状态，而搜索则可以排除一些无效状态。

下面就是推导状态转移方程了，这个题的子问题还是比较明显的：就是分两种大的情况，如果宝贝大于手中的价值，那么可以拿或者不拿，而如果小于则不拿。

另外要注意的地方：①宝物的价值可以为0，所以一开始搜索的时候，我们要将手中的价值设置为负数

                              ②有可能某条路径是不满题意的，即无解，那么此时dp就是0，所以我们要初始化dp为-1，

                                  以便把没搜索过的情况和搜索过但是无解的情况区分开来

好了，看代码吧：

import java.util.*;

public class Main {
    static Scanner in = new Scanner(System.in); 
    static int n,m,k,mod = 1000000007;
    static int[][][][] dp = new int[55][55][15][15];
    static int[][] mp = new int[55][55];
    static int dfs(int x,int y,int sum,int val) {
    	if(dp[x][y][sum][val+1]!=-1)//搜索过了，直接返回值
    		return dp[x][y][sum][val+1];
    	if(x==n-1&&y==m-1) {//到达出口
    		 if(sum==k)//宝物数目满足，可行
    			 return dp[x][y][sum][val+1] = 1;
    		 if(sum==k-1&&mp[x][y]>val)//少一件，但是这个点的宝物可取
    			 return dp[x][y][sum][val+1] = 1;
    		 return  dp[x][y][sum][val+1] = 0;
    	}
    	int t = 0;
    	if(x+1<=n) {//向下走
    		if(mp[x][y]>val) {//可以拿走
    			t = (t+ dfs(x+1,y,sum+1,mp[x][y]))%mod;
    			t%=mod;
    		 }
    		t = (t+ dfs(x+1,y,sum,val))%mod;//不拿走
			t%=mod;
    	}
    	if(y+1<=m) {//向右走
    		if(mp[x][y]>val) {//可以拿走
    			t = (t+ dfs(x,y+1,sum+1,mp[x][y]))%mod;
    			t%=mod;
    		 }
    		t = (t+ dfs(x,y+1,sum,val))%mod;//不拿走
			t%=mod;
    	}
    	return dp[x][y][sum][val+1] = t % mod;
    }
	public static void main(String[] args) {
			n= in.nextInt();
			m = in.nextInt();
			k = in.nextInt();
			int i,j,p,q;
			 for(i = 0;i < 55;i++)
				 for(j = 0;j < 55;j++) 
					 for(p = 0;p < 15;p++)
						 for(q = 0;q < 15;q++)
							 dp[i][j][p][q] = -1;
		 for(i = 0;i < n;i++)
			 for(j = 0;j < m;j++) {
				 mp[i][j] = in.nextInt();
			 }		 
		 System.out.println(dfs(0,0,0,-1));			
	}
}

 

public class Main {
	
	public static int n;
	public static int m;
	public static int k;
	public static int[][][][] dp = new int[50][50][15][15];//用于记忆搜索
	public static int[][] arr = new int[50][50];
	
	public static void main(String[] args) {
		//处理输入
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		m = sc.nextInt();
		k = sc.nextInt();
		for(int i = 0; i < n; i++){
			for(int j = 0; j < m; j++){
				arr[i][j] = sc.nextInt();
			}
		}
		initDp();//初始化记忆数组,不能用java初始的0值,因为很多格子只有0种可能, 会造成重复搜索. 
		System.out.println(process(arr, 0, 0, -1, 0));//宝藏的最小值为0, 所以初始的max值为-1
	}
	
	public static int process(int[][] arr, int x, int y, int max, int cur){
		if(dp[x][y][max + 1][cur] != -1){//max初始为-1,为防止越界填入max+1
			return dp[x][y][max + 1][cur];
		}
		if(x >= n || y >= m || cur > k){
			return 0;
		}
		int value = arr[x][y];
		if(x == n - 1 && y == m - 1){
			if(cur == k || (value > max && cur == k - 1)){
				return 1;
			}
			return 0;
		}
		int res = 0;
		if(value > max){//如果宝藏大于当前手上的最大值, 就可以拿走.
			res += process(arr, x, y + 1, value, cur + 1);//每次递归完对结果取模, 否则数据量大的时候会出错.
			res %= 1000000007;
			res += process(arr, x + 1, y, value, cur + 1);
			res %= 1000000007;
		}
		//不拿走
		res += process(arr, x, y + 1, max, cur);
		res %= 1000000007;
		res += process(arr, x + 1, y, max, cur);
		res %= 1000000007;
		
		dp[x][y][max + 1][cur] = res;
		return res;
	}
	
	public static void initDp(){
		for(int i = 0; i < 50; i++){
			for(int j = 0; j < 50; j++){
				for(int k = 0; k < 15; k++){
					for(int l = 0; l < 15; l++){
						dp[i][j][k][l] = -1;
					}
				}
			}
		}
	}
}