地宫取宝|2014年蓝桥杯B组题解析第九题-fishers

地宫取宝

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

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意: main函数需要返回0 注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。 注意: 所有依赖的函数必须明确地在源文件中 #include ， 不能通过工程设置而省略常用头文件。

提交时，注意选择所期望的编译器类型

思路：dfs模拟走格子，再出口处判断是否满足条件，这里出口处有细节点（代码中解释）

待改进：上面的思路超时了，只能过42%的数据。要用”记忆化搜索“改进（见文末）

代码一：

#include<iostream>
using namespace std;

long long ans = 0;
int arr[100][100];
int n,m,k;
int have[10010];

//判断是否能拿走当前坐标上的物件
bool canTake(int x,int y,int t){
	for(int i=1;i<=t;i++){
		if(have[i] >= arr[x][y]){
			return false;
		}
	}
	return true;
}

//dfs走格子
void dfs(int x,int y,int t){

	if(x == n && y == m){
//		（1）可能不算右下角的也正好
//		（2）如果右下角的比当前的大，算上这一个如果正好也可以增加路径
		if(t == k+1 || (t==k && canTake(n,m,t))){
			ans++;
			ans = ans % 1000000007;
		}
		return;
	}
	if(canTake(x,y,t)){
		have[t] = arr[x][y];
		if(x+1<=n){
			dfs(x+1,y,t+1);
		}
		if(y+1<=m){
			dfs(x,y+1,t+1);
		}
		have[t] = -1;
	}
	if(x+1<=n){
		dfs(x+1,y,t); //走右边
	}
	if(y+1<=m){
		dfs(x,y+1,t); //走下边
	}
}

int main(){
	cin>>n>>m>>k;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			cin>>arr[i][j];
		}
	}
	for(int i=1;i<=k;i++){
		have[i] = -1;
	}
	dfs(1,1,1);//横坐标 纵坐标  件数
	cout<<ans<<endl;
}

记忆型递归：就是“缓存”，使用数组或者map等等。存储当前状态对应的值（这里就是当前dfs参数下对应的方案数），

为什么要使用记忆型递归？因为中间结果重复过多，为了提高效率。

代码二：

#include <stdio.h>
#include <string.h>
#define N 1000000007
  int n,m,k;
  int map[50][50];
  int dp[50][50][15][15];//dp数组中记录的是状态   xy坐标 拥有宝物数量 拥有宝物的最大值(这4个可以详尽唯一的描述没一种可能)
                          //如dp[3][4][5][6]=7 即当在map[3][4]且身上有5件宝物 宝物的最大值是6 是到达终点有7中路径

  int dfs(int x,int y,int num,int max)//当前位置   拥有宝物的数量 拥有的宝物的最大值
 {
     if (dp[x][y][num][max]!=-1)//判断这个状态是否已经走过，如果走过就直接用记录的数值计算//因为宝物有可能为0所以定义max时用最小值-1 这就导致无法作为下标使用  实际上如果测试数据中宝物价值没有0
	                               //将所有的+1 去掉也是可以的   这里的话如果去掉肯定是有些数据不对的，不信可以提交试一下，根本过不了
         return dp[x][y][num][max];
       //记忆化的记忆就指的是上面

     if(x==n&&y==m){//到达出口
         if( num==k||(num==k-1&&max<map[x][y]) )  //到达右下角，（1）可能不算右下角的也正好，（2）如果右下角的比当前的大，算上这一个如果正好也可以增加路径
		    return dp[x][y][num][max]=1;  //满足条件 当前点到目标有1种方案
         else
		 return dp[x][y][num][max]=0;//不满足条件 当前点到目标有0种方案
     }
     long long s=0;
     if(x+1<=n){         //可以向下走
         if (max<map[x][y])
             s+=dfs(x+1,y,num+1,map[x][y]);//当前位置   拥有宝物的数量 拥有的宝物的最大值
         s+=dfs(x+1,y,num,max);            //当前位置   拥有宝物的数量 拥有的宝物的最大值
     }
     if(y+1<=m){         //可以向右走
         if (max<map[x][y])
             s+=dfs(x,y+1,num+1,map[x][y]);//当前位置   拥有宝物的数量 拥有的宝物的最大值
        s+=dfs(x,y+1,num,max);             //当前位置   拥有宝物的数量 拥有的宝物的最大值
     }
     return dp[x][y][num][max]=s%N;
 }
 int main(){
     scanf("%d%d%d",&n,&m,&k);
     for (int i = 1;i<=n;i++)//初始地宫
         for (int j = 1; j <=m; j++)
             scanf("%d",&map[i][j]);
     memset(dp,-1,sizeof(dp));
     dfs(1,1,0,-1);
     printf("%d\n",dp[1][1][0][-1]);

     return 0;
 }

解决数组下标为-1，可以将所有值+1

#include <iostream>
#include <cstring>

using namespace std;
const int MOD = 1000000007;
int n, m, k;
int data[50][50];

long long ans;
long long cache[50][50][14][13];

void dfs(int x, int y, int max, int cnt) {
    if (x == n || y == m || cnt > k)
        return;
    int cur = data[x][y];
    if (x == n - 1 && y == m - 1)
    {
        if (cnt == k || (cnt == k - 1 && cur > max)) {
            ans++;
            if (ans > MOD)
                ans %= MOD;
        }
    }
    if (cur > max) {
        dfs(x, y + 1, cur, cnt + 1);
        dfs(x + 1, y, cur, cnt + 1);
    }

    dfs(x, y + 1, max, cnt);
    dfs(x + 1, y, max, cnt);

}

long long dfs2(int x, int y, int max, int cnt) {

    if (cache[x][y][max+1][cnt] != -1)
        return cache[x][y][max+1][cnt];

    long long ans = 0;
    if (x == n || y == m || cnt > k)
        return 0;
    int cur = data[x][y];
    if (x == n - 1 && y == m - 1)
    {
        if (cnt == k || (cnt == k - 1 && cur > max)) {
            ans++;
            if (ans > MOD)
                ans %= MOD;
        }
        return ans;
    }
    if (cur > max) {
        ans += dfs2(x, y + 1, cur, cnt + 1);
        ans += dfs2(x + 1, y, cur, cnt + 1);
    }

    ans += dfs2(x, y + 1, max, cnt);
    ans += dfs2(x + 1, y, max, cnt);

    cache[x][y][max+1][cnt]=ans % MOD;
    return cache[x][y][max+1][cnt];
}

int main(int argc, const char *argv[]) {
    scanf("%d %d %d", &n, &m, &k);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            scanf("%d", &data[i][j]);
        }
    }
//    dfs(0, 0, -1, 0);
//    printf("%d\n", ans);
memset(cache,-1, sizeof(cache));
    printf("%lli\n", dfs2(0, 0, -1, 0));
    return 0;
}