DeepSeek网页端撰写Noip2008提高组第三题传纸条题解-优快云博客

本文链接：https://blog.youkuaiyun.com/liufangshun/article/details/145843918

发布完IMA+（DeepSeek or 混元）撰写Noip2008提高组第三题传纸条题解-优快云博客后突发奇想，使用相同的提问词，用网页版【Deepseek+深度思考R1+联网搜索】得到的回复与【IMA+(DeepSeek or 混元)】的回复有什么不一样的体验呢？本文中我把用网页版【Deepseek+深度思考R1+联网搜索】得到的回复发布如下。

一、提问词

请提供信息奥赛2008年提高组传纸条的题解，要求： 
1、从文件“message.in”读数据，答案写入文件“message.out”。 
2、不使用C++11以后版本的语法规则。 
3、解释题解中的主要算法。

二、DeepSeek回复

为了求解传纸条问题，我们需要找到两条从左上到右下的路径，使得路径上的数值之和最大，并且路径除了起点和终点外不重复。以下是详细题解：

算法思路

动态规划状态设计：使用三维状态 dp[s][i][k] 表示在步数 s 时，第一条路径到达第 i 行，第二条路径到达第 k 行的最大价值。由于步数相同，两条路径的行列之和相等，可以通过步数 s 和行数 i、k 推导出列数 j = s + 2 - i 和 l = s + 2 - k。
状态转移：对于每一步，考虑两条路径的上一步可能的位置（上边或左边），共有四种组合。通过遍历这些组合，找到最大价值的转移路径。
滚动数组优化空间：使用两个二维数组交替更新，减少空间复杂度。
路径不重复处理：确保除起点和终点外，两条路径不经过同一格子。

代码实现

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

const int MAX_M = 55;
const int MAX_N = 55;
int grid[MAX_M][MAX_N];
int dp[2][MAX_M][MAX_M]; // 使用滚动数组优化空间

int main() {
    freopen("message.in", "r", stdin);
    freopen("message.out", "w", stdout);

    int M, N;
    scanf("%d%d", &M, &N);
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < N; ++j) {
            scanf("%d", &grid[i][j]);
        }
    }

    memset(dp, -1, sizeof(dp));
    int prev = 0, curr = 1;
    dp[prev][1][1] = grid[0][0]; // 初始状态，s=0

    const int s_max = M + N - 2;
    for (int s = 1; s <= s_max; ++s) {
        memset(dp[curr], -1, sizeof(dp[curr]));
        for (int i = 1; i <= M; ++i) {
            int j = s + 2 - i;
            if (j < 1 || j > N) continue;

            for (int k = 1; k <= M; ++k) {
                int l = s + 2 - k;
                if (l < 1 || l > N) continue;

                // 检查是否为同一非起点/终点格子
                bool same = (i == k) && (j == l);
                if (same && !(i == 1 && j == 1) && !(i == M && j == N)) {
                    continue;
                }

                // 计算当前格子的价值
                int val;
                if (same) {
                    val = grid[i-1][j-1];
                } else {
                    val = grid[i-1][j-1] + grid[k-1][l-1];
                }

                // 寻找前驱状态的最大值
                int max_val = -1;
                for (int a = 0; a <= 1; ++a) {
                    int pi = i - a;
                    if (pi < 1) continue;
                    int pj_prev = (s-1) + 2 - pi;
                    if (pj_prev < 1 || pj_prev > N) continue;

                    for (int b = 0; b <= 1; ++b) {
                        int pk = k - b;
                        if (pk < 1) continue;
                        int pl_prev = (s-1) + 2 - pk;
                        if (pl_prev < 1 || pl_prev > N) continue;

                        if (dp[prev][pi][pk] != -1) {
                            max_val = max(max_val, dp[prev][pi][pk] + val);
                        }
                    }
                }

                if (max_val != -1) {
                    dp[curr][i][k] = max_val;
                }
            }
        }
        swap(prev, curr);
    }

    printf("%d\n", dp[prev][M][M]);
    return 0;
}