微策略2012年校园招聘笔试题两道-动态规划和DFS练习

一、棋盘寻宝

题目描述：

现在有一个8*8的棋盘，上面放着64个价值不等的礼物，每个小的棋盘上面放置一个礼物（礼物的价值大于0小于1000），一个人的初始位置在棋盘的左上角，每次他只能向下或向右移动一步，并拿走对应棋盘上的礼物，结束位置在棋盘的右下角，请设计一个算法使其能够获得最大价值的礼物。

输入：

输入包含多个测试用例，每个测试用例共有8行8列，第i行的第j列的数字代表了该处棋盘上的礼物的价值，每两个数之间用空格隔开。

输出：

对于每组测试用例，请输出你能够获得最大价值的礼物。

样例输入：

2 8 15 1 10 5 19 19
3 5 6 6 2 8 2 12
16 3 8 17 12 5 3 14
13 3 2 17 19 16 8 7
12 19 10 13 8 20 16 15
4 12 3 14 14 5 2 12
14 9 8 5 3 18 18 20
4 2 10 19 17 16 11 3

样例输出：

194

简单的动态规划，最优子结构很明显。 dp[i][j]能取得的最大值，取决于dp[i-1][j],dp[i][j-1]的最大值

这里对第一行和第一列单独处理，因为只能向右和向下。

map[i][j] += max(map[i-1][j], map[i][j-1])

#include <stdio.h>
int map[8][8], i, j, ans;
int main() {
	while (~scanf("%d", &map[0][0])) {
		for (j = 1; j < 8; j++) {
			scanf("%d", &map[0][j]);
			map[0][j] += map[0][j - 1];
		}
		for (i = 1; i < 8; i++) {
			scanf("%d", &map[i][0]);
			map[i][0] += map[i - 1][0];
			for (j = 1; j < 8; j++) {
				scanf("%d", &map[i][j]);
				map[i][j] += (
						map[i][j - 1] > map[i - 1][j] ?
								map[i][j - 1] : map[i - 1][j]);
			}
		}
		printf("%d\n", map[7][7]);
	}
	return 0;
}

二、棋盘寻宝扩展

题目描述：

现在有一个8*8的棋盘，上面放着64个不同价值的礼物，每个小的棋盘上面放置一个礼物（礼物的价值大于0小于100），一个人初始位置在棋盘的左上角，每次他只能向下或向右移动一步，并拿走对应棋盘上的礼物，结束位置在棋盘的右下角。从棋盘的左上角移动到右下角的时候的，每次他只能向下或向右移动一步，并拿走对应棋盘上的礼物，但是拿到的所有的礼物的价值之和不大于一个限定值limit，请设计一个算法请实现，使其能够获得不超过限制值limit的最大价值的礼物。

输入：

输入包含多个测试用例，每个测试用例共有9行，第一行是一个限制值limit<=1000，下面还有8行8列，第i行的第j列的数字代表了该处棋盘上的礼物的价值，每两个数之间用空格隔开。

输出：

对于每组测试用例，请输出你能够获得不超过限制值limit的最大价值的礼物。若没有符合条件的线路则输出-1。

样例输入：

90
4 2 5 1 3 8 9 7
4 5 2 3 7 1 8 6
7 2 1 8 5 9 3 6
2 8 9 5 6 3 1 7
1 2 4 5 3 7 9 6
3 5 7 8 9 6 2 4
10 8 1 4 7 5 3 9
7 4 6 2 1 3 9 8

样例输出：

90

加了限制，这时只能考虑所有情况了。这里使用dfs求解，加上剪枝:

if (sum > limit) return;

#include <stdio.h>
int map[8][8], i, j, ans, limit;
void f(int x, int y, int sum) {
	sum += map[x][y];
	if (sum > limit)
		return;
	if (x == 7 && y == 7 && sum > ans)
		ans = sum;
	if (x < 7)
		f(x + 1, y, sum);
	if (y < 7)
		f(x, y + 1, sum);
}

int main() {
	while(~scanf("%d",&limit)) {
		ans = 0;
		for(i=0; i<8; i++) {
			for(j=0; j<8; j++) {
				scanf("%d",&map[i][j]);
			}
		}
		f(0,0,0);
		if(ans > 0)
		printf("%d\n",ans);
		else puts("-1");
	}
	return 0;
}

也有用动态规划求解的，不是很直观。时间复杂度其实是一样的，也要考虑所有情况。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

bool dp[10][10][1010];
int a[10][10];

int main()
{
    int n;
	freopen("in.txt", "r", stdin);
    while(scanf("%d",&n) != EOF) {
        for(int i = 1; i <= 8; i ++)
            for(int j = 1; j <= 8; j ++)
                scanf("%d",&a[i][j]);
        memset(dp,false,sizeof(dp));
        if(a[1][1] > n) {
            printf("-1\n");
            continue;
        }
        dp[1][1][a[1][1]] = true;
        for(int i = 1; i <= 8; i ++)
            for(int j = 1; j <= 8; j ++)
                for(int k = 0; k <= n; k ++)
                    if(dp[i][j][k]) {
                        if(j < 8 && k + a[i][j + 1] <= n)
                            dp[i][j + 1][k + a[i][j + 1]] = true;
                        if(i < 8 && k + a[i + 1][j] <= n)
                            dp[i + 1][j][k + a[i + 1][j]] = true;
                    }
        int ans = -1;
        for(int i = n; i >= 0; i --)
            if(dp[8][8][i]) {
                ans = i;
                break;
            }
        printf("%d\n",ans);
    }
    return 0;
}