信息学奥赛一本通题目解析：1277：【例9.21】方格取数(动态规划)

【题目描述】

设有N×N的方格图，我们在其中的某些方格中填入正整数，而其它的方格中则放入数字0。如下图所示：

某人从图中的左上角A出发，可以向下行走，也可以向右行走，直到到达右下角的B点。在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字0）。

此人从A点到B点共走了两次，试找出两条这样的路径，使得取得的数字和为最大。

【输入】

第一行为一个整数N（N≤10），表示N×N的方格图。

接下来的每行有三个整数，第一个为行号数，第二个为列号数，第三个为在该行、该列上所放的数。一行“0 0 0”表示结束。

【输出】

第一个整数，表示两条路径上取得的最大的和。

【输入样例】

8
2 3 13
2 6 6
3 5 7
4 4 14
5 2 21
5 6 4
6 3 15
7 2 14
0 0 0

【输出样例】

67

【解题思路】

问题的关键在于理解如何同时规划两条路径以使得取得的数字和最大化。由于两条路径都是从左上角到右下角，且可以只向下或向右移动，因此它们在某些点一定会相交。在相交的点上，取走数字的操作只能算一次。基于这个理解，我们可以通过动态规划来找到最优解。以下是解题思路：

1. 定义状态

首先，我们定义一个四维数组dp[x1][y1][x2][y2]，其中x1, y1表示第一条路径到达的位置，x2, y2表示第二条路径到达的位置。dp[x1][y1][x2][y2]的值表示在第一条路径到达(x1, y1)，第二条路径到达(x2, y2)时，可以取得的最大数字和。

2. 状态转移方程

对于每一个状态dp[x1][y1][x2][y2]，有四种状态转移方式，因为每条路径可以向下或向右移动：

• 如果两条路径都向下移动，则状态转移是dp[x1+1][y1][x2+1][y2]。
• 如果路径一向右而路径二向下移动，则状态转移是dp[x1][y1+1][x2+1][y2]。
• 如果路径一向下而路径二向右移动，则状态转移是dp[x1+1][y1][x2][y2+1]。
• 如果两条路径都向右移动，则状态转移是dp[x1][y1+1][x2][y2+1]。

对于每一种状态转移，我们需要计算能够取得的最大数字和。如果两条路径在移动后到达了同一个点，则这个点上的数只能被计算一次；否则，这两个点上的数都可以被加到总和中。

状态转移方程可以表示为：

plaintextCopy code

dp[x1][y1][x2][y2] = max(dp[x1][y1][x2][y2], dp[x1'][y1'][x2'][y2'] + grid[x1][y1] + (x1 == x2 && y1 == y2 ? 0 : grid[x2][y2]))

其中x1', y1', x2', y2'分别代表之前的状态，grid[x][y]代表在(x, y)位置的数字。

3. 初始化

• 初始化所有的dp值为一个非常小的数，因为我们要求的是最大值。
• 对于起点，即dp[1][1][1][1]，它的值应该是grid[1][1]的值，因为两条路径起始都在这一点。

4. 计算顺序

从左上角开始，向右下角逐步计算所有的dp值。由于每一步都依赖于之前的状态，我们可以按照从上到下，从左到右的顺序来填充这个四维数组。

5. 寻找答案

最终答案是dp[N][N][N][N]的值，代表了两条路径都到达右下角时能取得的最大数字和。

实现提示

• 实际实现时，由于N的最大值为10，四维数组可能会消耗较多的内存。在C++中，这通常是可接受的，但在一些对内存敏感的环境下可能需要考虑优化。
• 由于问题的特殊性（只能向下或向右移动），实际上x1+y1的值等于x2+y2时，两条路径才可能在同一层。这个性质可以用来减少不必要的计算。

【代码实现】

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

const int MAX_N = 10;
int grid[MAX_N + 1][MAX_N + 1] = {0}; // 存储每个点的值
int dp[MAX_N + 1][MAX_N + 1][MAX_N + 1][MAX_N + 1] = {0}; // 动态规划数组

int main() {
    int N, x, y, val;
    cin >> N;
    while (cin >> x >> y >> val, x || y || val) {
        grid[x][y] = val;
    }

    // 动态规划求解
    for (int x1 = 1; x1 <= N; ++x1) {
        for (int y1 = 1; y1 <= N; ++y1) {
            for (int x2 = 1; x2 <= N; ++x2) {
                for (int y2 = 1; y2 <= N; ++y2) {
                    int sum = grid[x1][y1];
                    if (x1 != x2 || y1 != y2) {
                        sum += grid[x2][y2]; // 两者不在同一个位置时，加上第二个点的值
                    }
                    int& dp_curr = dp[x1][y1][x2][y2];
                    dp_curr = max(dp_curr, dp[x1-1][y1][x2-1][y2] + sum); // 两条路径都向下
                    dp_curr = max(dp_curr, dp[x1][y1-1][x2][y2-1] + sum); // 两条路径都向右
                    dp_curr = max(dp_curr, dp[x1-1][y1][x2][y2-1] + sum); // 路径一向下，路径二向右
                    dp_curr = max(dp_curr, dp[x1][y1-1][x2-1][y2] + sum); // 路径一向右，路径二向下
                }
            }
        }
    }

    // 输出最终结果，两条路径在N,N处结束的最大值
    cout << dp[N][N][N][N] << endl;
    return 0;
}