蓝桥杯+地宫取宝（动态规划+DFS）

问题描述
　　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

话说这个题目意图还是蛮明显的，深搜完后返回所有满足的解的个数，不过这个善意的题目，要想完全正确还是学需要在处理时注意很多方面。

首先，先来谈第一个问题，写出其状态转移方程，我们要求的解是从原点手握价值最大的宝物v开始经过不同的路径到终点获得K件宝物的路径总数，我们姑且将此状态记为

d(1,1,k(初始为0，还没拿宝贝),-1(此时手上没有宝物，值记为-1))

那么从此状态出发，可以将其转移为如下的决策

 

这里在补充说明用状态转移方程可以方便将原问题分解成若干个与原问题相同的子问题，且规模变小。

第二个问题，如果仅仅这样的话，必然存在重复计算的问题，为此必须要采取记忆化搜索的方式，对于已经计算过的结点保存其值，就这条题目而言，必须要用一个四维数组保存，因为它的状态跟位置，

物价值有关。当重复遍历这个结点时，直接传值。

第三个问题，细节决定成败！！

1.类型用long long稳妥，因为即使MOD了，但是如果两个数加起来还有可能超int。

2.我自己做的时候没注意的一个小错误，导致最后始终不对的疏忽。我错误的把r[MAXN][MAXN][15][15]的初始化为了0，这绝对不正确，因为有可能以某种方式走的状态就是无解，就是0，必须将初始值赋为-1。

3.对于有宝物的初始价值为-1，比较好的处理方式是，最后存放是第四维的下标后移一位

4.这里还要注意,k最多是13，不会超过这个值，所以第三维只要14就够了

我的代码在蓝桥杯官网oj超时了！看到后求优化，求指点！思路是看的别人点击打开链接望见谅！

下面看代码！！

import java.util.Scanner;

public class Main {
	static int n, m, k;
	static int[][] map;
	static int count = 1;
	static int[][][][] dp=new int[51][51][15][15];
	static int MOD= 1000000007 ;
//	static int s=0;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		m = sc.nextInt();
		k = sc.nextInt();
		map = new int[n + 1][m + 1];
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= m; j++) {
				map[i][j] = sc.nextInt();
			}
		}
		dfs(1,1,0,-1);
		System.out.println(dfs(1,1,0,-1));
	}
	//x y 记录当前位置的坐标，have为拥有宝物的数量，max为当前拥有的宝物中最大的价值
	private static int dfs(int x, int y, int have, int max) {
		// TODO Auto-generated method stub]
		int s=0;
		if(x == n && y == m)
		{
			if(have == k)
			{
				dp[n][m][have][max+1]=1;
				return dp[n][m][have][max+1];
			}
			else if( have == k-1 && map[n][m] > max)
			{
				dp[n][m][have][max+1]=1;
				return dp[n][m][have][max+1];
			}
			else
			{
				dp[n][m][have][max+1]=0;
				return dp[n][m][have][max+1];
			}
		}
		else
		{
			if(map[x][y]>max)
	        {
	           int t=map[x][y];
	            if(x+1<=n)
	            s=(s+dfs(x+1,y,have+1,t)%MOD+dfs(x+1,y,have,max)%MOD)%MOD;
	            if(y+1<=m)
	            s=(s+dfs(x,y+1,have+1,t)%MOD+dfs(x,y+1,have,max)%MOD)%MOD;
	        }
	        else
	        {
	            if(x+1<=n)
	            s=(s+dfs(x+1,y,have,max)%MOD)%MOD;
	            if(y+1<=m)
	            s=(s+dfs(x,y+1,have,max)%MOD)%MOD;
	        }
	        dp[x][y][have][max+1]=s %MOD;
	        return dp[x][y][have][max+1];
		}
	}

}