nyoj 61 传纸条（一）双线程DP

最新推荐文章于 2018-09-14 11:30:45 发布

转载最新推荐文章于 2018-09-14 11:30:45 发布 · 489 阅读

DP 专栏收录该内容

14 篇文章

订阅专栏

本文探讨了一种特定场景下的最优化路径问题——传纸条问题。问题设定为两名学生位于班级矩阵对角线两端，需通过传递纸条交流，过程中纸条需经过班级同学传递。文章提供了一种动态规划解决方案，确保选择最佳路径使得所经过的同学‘好心程度’总和最大。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

传纸条（一）

时间限制：2000 ms | 内存限制：65535 KB

难度：5

描述

小渊和小轩是好朋友也是同班同学，他们在一起总有谈不完的话题。一次素质拓展活动中，班上同学安排做成一个m行n列的矩阵，而小渊和小轩被安排在矩阵对角线的两端，因此，他们就无法直接交谈了。幸运的是，他们可以通过传纸条来进行交流。纸条要经由许多同学传到对方手里，小渊坐在矩阵的左上角，坐标(1,1)，小轩坐在矩阵的右下角，坐标(m,n)。从小渊传到小轩的纸条只可以向下或者向右传递，从小轩传给小渊的纸条只可以向上或者向左传递。

在活动进行中，小渊希望给小轩传递一张纸条，同时希望小轩给他回复。班里每个同学都可以帮他们传递，但只会帮他们一次，也就是说如果此人在小渊递给小轩纸条的时候帮忙，那么在小轩递给小渊的时候就不会再帮忙。反之亦然。

还有一件事情需要注意，全班每个同学愿意帮忙的好感度有高有低（注意：小渊和小轩的好心程度没有定义，输入时用0表示），可以用一个0-1000的自然数来表示，数越大表示越好心。小渊和小轩希望尽可能找好心程度高的同学来帮忙传纸条，即找到来回两条传递路径，使得这两条路径上同学的好心程度之和最大。现在，请你帮助小渊和小轩找到这样的两条路径。

输入

第一行输入N(0<N<100)表示待测数据组数。
每组测试数据输入的第一行有2个用空格隔开的整数m和n，表示班里有m行n列（2<=m,n<=50）。
接下来的m行是一个m*n的矩阵，矩阵中第i行j列的整数表示坐在第i行j列的学生的好心程度（不大于1000）。每行的n个整数之间用空格隔开。

输出

每组测试数据输出共一行，包含一个整数，表示来回两条路上参与传递纸条的学生的好心程度之和的最大值。

样例输入

样例输出

下面讲一下最简单的三维方法：

F[dep,x1,x2]表示当两张纸条都走了dep步，且第一张纸条横坐标为x1，第二张纸条横坐标为x2时所能取到的最大好心值。先看状态转移方程：

F[dep,x1,x2]=max{f[dep-1,x1,x2],f[dep-1,x1-1,x2],f[dep-1,x1,x2-1],f[dep-1,x1-1,x2-1]}

当然x1、x2都是有范围的，首先看边界：f[2,1,1]=0,所以两个横坐标的范围是：1<=x1,x2<=dep-1。要求的目标状态是f[m+n,m,m]。

注意，题目中还说了，一名同学只能帮助传纸条1次，所以在f[dep,x1,x2]中，当（x1=x2） and not（（dep=m+n）and（x1=m）and（x2=m））时，即不是目标状态，且两纸条走到了同一格内，此时不应考虑这个状态，在动态规划实现的时候应将其滤去。

具体实现时，相比之下，这个方程用记忆化搜索应该更容易实现。

#include<stdio.h>
#include<string.h>

int a[61][61] = {0}; // 好感度数组
int f[105][61][61] = {0};
int max(int a,int b)
{
    return a > b ? a : b;
}
int main()
{
    int m,n,N;
    scanf("%d",&N);
    while(N--)
    {
        memset(f,0,sizeof(f));
        scanf("%d%d",&m,&n);
        for(int i = 1; i <= m; ++i)
            for(int j = 1; j <= n; ++j)
                scanf("%d", &a[i][j]);

        // 开始循环解题
        for(int i = 2; i <= n+m-2; ++i)/*延伸两条路径的长度*/
            for(int j = 1; j <= m; ++j)/*枚举两条路径当前行的位置*/
                for(int k = 1; k <= m; ++k)
            {
                int y1 = i - j + 1;/*计算当前两条路径的列位置*/
                int y2 = i - k + 1;
                if(!(y1>0 && y2 > 0 && y1 <= n&& y2 <= n)||j==k)
                    continue;/*如果当前两条路径列的位置越出界或者同处一行，继续枚举*/

                f[i][j][k] = max(f[i][j][k],f[i-1][j][k]);/*情况1，两条路径都向右走*/

                if(j-1!=k) /*情况2 ，第一条向下，第二条向右*/
                    f[i][j][k] = max(f[i][j][k],f[i-1][j-1][k]);
                if(j != k-1 ) /*情况3 ，第一条向右 ，第二条向下*/
                    f[i][j][k] = max(f[i][j][k],f[i-1][j][k-1]);

                f[i][j][k] = max(f[i][j][k],f[i-1][j-1][k-1]);/*情况4.都向下*/

                f[i][j][k]+=a[j][y1]+a[k][y2];

            }
        printf("%d\n", f[m+n-2][m][m-1]);  // 输出由两条不交叉的线路走到右下角时的最大好感度和
    }
    return 0;
}

/*用四维数组来动态规划解决了这倒题。
设f[i][j][k][l]为从 (0, 0) 位置由两条不交叉的线路走到 (i, j)，(k, l) 位置时的最大好感度和，则它的上一步可能有四种情况：
第一个点由上走来，第二个点也由上走来，此时的好感度和为f[i - 1][j][k - 1][l] + a[i][j] + a[k][l]
第一个点由上走来，第二个点则由左走来，此时的好感度和为f[i - 1][j][k][l - 1] + a[i][j] + a[k][l]，但此时应考虑第一个点的上方的点是否会与第二个点的左方的点重合，如果重合则不可取
第一个点由左走来，第二个点则由上走来，此时的好感度和为f[i][j - 1][k - 1][l] + a[i][j] + a[k][l]，但此时应考虑第一个点的左方的点是否会与第二个点的上方的点重合，如果重合则不可取
第一个点由左走来，第二个点也由左走来，此时的好感度和为f[i][j - 1][k][l - 1] + a[i][j] + a[k][l]
取四种情况中的最大者即可。
*/

注意：这种方法虽然简单，易懂，但容易超时

#include<stdio.h>
int a[52][52] = {0}; // 好感度数组
int f[52][52][52][52] = {0}; // 动态规划数组，f[i][j][k][l] 表示从 (0, 0) 位置由两条不交叉的线路走到 (i, j)，(k, l) 位置时的最大好感度和
int max(int a, int b)
{
    return a > b ? a : b;
}
int main()
{
    int m, n,N;
    scanf("%d",&N);
    while(N--)
    {
        scanf("%d%d", &m, &n);
        for(int i = 1; i <= m; ++i)
            for(int j = 1; j <= n; ++j)
                scanf("%d", &a[i][j]);
            
        // 开始循环解题
        for(int i = 1; i <= m; ++i)
            for(int j = 1; j <= n; ++j)
                for(int k = 1; k <= m; ++k)
                    for(int l = 1; l <= n; ++l){
            // 还没到终点前不能走到同一个点，因此(i, j)不能等于(k, l)
            // 加上小于判断是因为当(i, j)跟(k, l)互换时，最大好感度值必定一样，不必重复计算
            if((i < m || j < n) && i <= k && j <= l)
            {
                continue;
            }
            int num = 0; 
            //第一种情况： 两个点都由上走来的好感度
            num = max(num, f[i - 1][j][k - 1][l]);
            
            //第二种情况： 第一个点由上走来，第二个点从左走来，并且两个来源点不重合时的好感度
            if(i - 1 != k && j != l - 1)
                num = max(num, f[i - 1][j][k][l - 1]);
                    
            // 第三种情况：第一个点由左走来，第二个点从上走来，并且两个来源点不重合时的好感度
            if(i != k - 1 && j - 1 != l)
                num = max(num, f[i][j - 1][k - 1][l]);

            //第四种情况：两个点都由左走来的好感度
            num = max(num, f[i][j - 1][k][l - 1]);
            
            f[i][j][k][l] = num + a[i][j] + a[k][l];// 加上当前两点的好感度，即为走到这两点时的最大好感度和
            }
        printf("%d\n", f[m][n][m][n]);  // 输出由两条不交叉的线路走到右下角时的最大好感度和
    }
    return 0;
}