当前位置：网站首页>nyoj 712 探寻宝藏（双线dp 第六届河南省程序设计大赛）

nyoj 712 探寻宝藏（双线dp 第六届河南省程序设计大赛）

2022-08-08 18:34:00 【51CTO】

探寻宝藏

1000 ms | 内存限制： 65535

传说HMH大沙漠中有一个M*N迷宫，里面藏有许多宝物。某天，Dr.Kong找到了迷宫的地图，他发现迷宫内处处有宝物，最珍贵的宝物就藏在右下角，迷宫的进出口在左上角。当然，迷宫中的通路不是平坦的，到处都是陷阱。Dr.Kong决定让他的机器人卡多去探险。

但机器人卡多从左上角走到右下角时，只会向下走或者向右走。从右下角往回走到左上角时，只会向上走或者向左走，而且卡多不走回头路。（即：一个点最多经过一次）。当然卡多顺手也拿走沿路的每个宝物。

Dr.Kong希望他的机器人卡多尽量多地带出宝物。请你编写程序，帮助Dr.Kong计算一下，卡多最多能带出多少宝物。

第一行： K 表示有多少组测试数据。

接下来对每组测试数据：

第1行: M N

第2~M+1行： Ai1 Ai2 ……AiN (i=1,…..,m)

【约束条件】

2≤k≤5 1≤M, N≤50 0≤Aij≤100 (i=1,….,M; j=1,…,N)

所有数据都是整数。数据之间有一个空格。

输出对于每组测试数据，输出一行：机器人卡多携带出最多价值的宝物数样例输入

样例输出

来源第六届河南省程序设计大赛

上传者 ACM_赵铭浩

这道题和以往我们做的dp不同之处就在于是一去一回

加入只有去我们可以用动态规划方程 dp[i][j]=max(dp[i-1][j],dp[i][j-1])+map[i][j].

而这道题去了又回来我们可以理解为两个人同时从左上角去不过不走相同的路

如果两个人不走相同的路那么这两个人必须不在相同的列或者行又因为两个人走的步数完全相同

所以我们可以通过一个人走的步数得到另外一个人走的步数

我们可以通过一个四维的数组来保存

于是这个时候的动态规划方程

       
       dp[i][j][k][l]=max(max(dp[i-1][j][k-1][l],dp[i-1][j][k][l-1]),
       
29.
       
max(dp[i][j-1][k-1][l],dp[i][j-1][k][l-1]))+map[i][j]+map[k][l];
      
1.
2.
3.

附上代码：

       
       #include <stdio.h>
       
       #include <string.h>
       
       #include <algorithm>
       
       using 
       
       namespace 
       
       std;
       
       int 
       
       map[
       
       55][
       
       55];  
       
       int 
       
       dp[
       
       55][
       
       55][
       
       55][
       
       55];
       
       int 
       
       main()
       
{
       
       int 
       
       ncase;
       
       scanf(
       
       "%d",
       
       &
       
       ncase);
       
       while(
       
       ncase
       
       --)
       
  {
       
       int 
       
       n,
       
       m;
       
       memset(
       
       dp,
       
       0,
       
       sizeof(
       
       dp));
       
       memset(
       
       map,
       
       0,
       
       sizeof(
       
       map));
       
       scanf(
       
       "%d %d",
       
       &
       
       m,
       
       &
       
       n);
       
       for(
       
       int 
       
       i
       
       =
       
       1;
       
       i
       
       <=
       
       m;
       
       i
       
       ++)
       
       for(
       
       int 
       
       j
       
       =
       
       1;
       
       j
       
       <=
       
       n;
       
       j
       
       ++)
       
       scanf(
       
       "%d",
       
       &
       
       map[
       
       i][
       
       j]);
       
       for(
       
       int 
       
       i
       
       =
       
       1;
       
       i
       
       <=
       
       m;
       
       i
       
       ++)
       
       for(
       
       int 
       
       j
       
       =
       
       1;
       
       j
       
       <=
       
       n;
       
       j
       
       ++)
       
       for(
       
       int 
       
       k
       
       =
       
       i
       
       +
       
       1;
       
       k
       
       <=
       
       m;
       
       k
       
       ++)
       
        {
       
       int 
       
       l
       
       =
       
       i
       
       +
       
       j
       
       -
       
       k;
       
       if(
       
       l
       
       <
       
       0
       
       ||
       
       l
       
       >
       
       n)
       
       break;
       
       dp[
       
       i][
       
       j][
       
       k][
       
       l]
       
       =
       
       max(
       
       max(
       
       dp[
       
       i
       
       -
       
       1][
       
       j][
       
       k
       
       -
       
       1][
       
       l],
       
       dp[
       
       i
       
       -
       
       1][
       
       j][
       
       k][
       
       l
       
       -
       
       1]),
       
       max(
       
       dp[
       
       i][
       
       j
       
       -
       
       1][
       
       k
       
       -
       
       1][
       
       l],
       
       dp[
       
       i][
       
       j
       
       -
       
       1][
       
       k][
       
       l
       
       -
       
       1]))
       
       +
       
       map[
       
       i][
       
       j]
       
       +
       
       map[
       
       k][
       
       l];
       
        }
       
       printf(
       
       "%d\n",
       
       max(
       
       max(
       
       dp[
       
       m][
       
       n
       
       -
       
       1][
       
       m
       
       -
       
       1][
       
       n],
       
       dp[
       
       m][
       
       n
       
       -
       
       1][
       
       m][
       
       n
       
       -
       
       1]),
       
       max(
       
       dp[
       
       m
       
       -
       
       1][
       
       n][
       
       m
       
       -
       
       1][
       
       n],
       
       dp[
       
       m
       
       -
       
       1][
       
       n][
       
       m][
       
       n
       
       -
       
       1]))
       
       +
       
       map[
       
       m][
       
       n]);
       
  }
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.

由于四维数组占用的空间特别大又因为在这道题中两个人走的步数完全相同也就是i+j=k+l 所以我们可以通过步数转换为3维的

dp[k][i][j] 其中k为当前走的步数 i为第一个人的行左边 j为第二个人的行坐标

又因为我所建的图左上角坐标为（1,1）所以从左上角到右下角需要的最少步数为m+n-2

这个时候的动态转移方程为

       
       dp[k][i][j]=max(max(dp[k-1][i-1][j],dp[k-1][i-1][j-1]),
       
max(dp[k-1][i][j],dp[k-1][i][j-1]))+map[i][k-i+2]+map[j][k-j+2];
      
1.
2.
3.

ac代码：

       
       #include <stdio.h>
       
       #include <string.h>
       
       #include <algorithm>
       
       using 
       
       namespace 
       
       std;
       
       int 
       
       map[
       
       55][
       
       55];  
       
       int 
       
       dp[
       
       110][
       
       55][
       
       55];
       
       int 
       
       main()
       
{
       
       int 
       
       ncase;
       
       scanf(
       
       "%d",
       
       &
       
       ncase);
       
       while(
       
       ncase
       
       --)
       
  {
       
       int 
       
       n,
       
       m;
       
       memset(
       
       dp,
       
       0,
       
       sizeof(
       
       dp));
       
       memset(
       
       map,
       
       0,
       
       sizeof(
       
       map));
       
       scanf(
       
       "%d %d",
       
       &
       
       m,
       
       &
       
       n);
       
       for(
       
       int 
       
       i
       
       =
       
       1;
       
       i
       
       <=
       
       m;
       
       i
       
       ++)
       
       for(
       
       int 
       
       j
       
       =
       
       1;
       
       j
       
       <=
       
       n;
       
       j
       
       ++)
       
       scanf(
       
       "%d",
       
       &
       
       map[
       
       i][
       
       j]);
       
       int 
       
       step
       
       =
       
       m
       
       +
       
       n
       
       -
       
       2;
       
       for(
       
       int 
       
       i
       
       =
       
       1;
       
       i
       
       <=
       
       m;
       
       i
       
       ++)
       
       for(
       
       int 
       
       j
       
       =
       
       i
       
       +
       
       1;
       
       j
       
       <=
       
       m;
       
       j
       
       ++)  
       
       for(
       
       int 
       
       k
       
       =
       
       1;
       
       k
       
       <
       
       step;
       
       k
       
       ++)
       
        {
       
       if(
       
       k
       
       +
       
       2
       
       >=
       
       i
       
       &&
       
       k
       
       +
       
       2
       
       >=
       
       j)
       
          {
       
       dp[
       
       k][
       
       i][
       
       j]
       
       =
       
       max(
       
       max(
       
       dp[
       
       k
       
       -
       
       1][
       
       i
       
       -
       
       1][
       
       j],
       
       dp[
       
       k
       
       -
       
       1][
       
       i
       
       -
       
       1][
       
       j
       
       -
       
       1]),
       
       max(
       
       dp[
       
       k
       
       -
       
       1][
       
       i][
       
       j],
       
       dp[
       
       k
       
       -
       
       1][
       
       i][
       
       j
       
       -
       
       1]))
       
       +
       
       map[
       
       i][
       
       k
       
       -
       
       i
       
       +
       
       2]
       
       +
       
       map[
       
       j][
       
       k
       
       -
       
       j
       
       +
       
       2];
       
          }
       
        }
       
       printf(
       
       "%d\n",
       
       max(
       
       dp[
       
       step
       
       -
       
       1][
       
       m][
       
       m
       
       -
       
       1],
       
       dp[
       
       step
       
       -
       
       1][
       
       m
       
       -
       
       1][
       
       m])
       
       +
       
       map[
       
       m][
       
       n]);
       
  }
       
       return 
       
       0;
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.