dp Codeforces 429B B. Working out

最新推荐文章于 2024-08-28 22:49:31 发布

原创最新推荐文章于 2024-08-28 22:49:31 发布 · 529 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#codeforces #dp

★ACM基础知识同时被 3 个专栏收录

125 篇文章

订阅专栏

--------【动态规划】

58 篇文章

订阅专栏

----------------【基础dp】

39 篇文章

订阅专栏

本文介绍了一个涉及矩阵中寻找最大价值路径的问题，通过动态规划的方法来解决两个角色如何在矩阵中移动以获得最大的总收益，同时确保他们在某个点相遇但不重复计算该点的价值。

Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.

Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].

There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.

If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.

Input

The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).

Output

The output contains a single number — the maximum total gain possible.

Sample test(s)

input
3 3
100 100 100
100 1 100
100 100 100

output
800

Note

Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3].

题意：

有一个n*m的矩阵，每个点有一个value，现在A站在位置(1,1)处，他只能向右或者向下走到点(n,m)处，B站在位置(n,1)处，他能向右或者向下走到点(1,m)处，两人的速度不一样，走到的格子可以获得该格子上面的value，但是两人相遇的位置上的value两人都不能拿。现在问两人最终能得到的value的和的最大值。

分析：

乱搞dp。没什么套路，预处理四个角到每个点的最大值。然后枚举每个点当作A和B相遇的点求出最大值就可以了。但是我们注意到，肯定是只有一个相遇点时值最大，所以我们可以想到，一定是1,3角横着或者竖着穿过点(i,j).

嗯，角是这样分布的

1 4

2 3

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>

using namespace std;

#define LL long long

int const maxn = 1100;
int a[maxn][maxn];
LL dp[5][maxn][maxn];
//dp[1][i][j]表示的是从第一个角到点(i,j)经过值的最大和

int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)==2)
    {
        memset(a,0,sizeof(a));
        for(int i = 1 ; i <= n ; i++)
        {
            for(int j = 1 ; j <= m ; j++)
            {
                scanf("%d",&a[i][j]);
            }
        }
        memset(dp,0,sizeof(dp));
        for(int i = 1 ; i <= n ; i++)
        {
            for(int j = 1 ; j <= m ; j++)
            {
                dp[1][i][j] = max(dp[1][i-1][j] , dp[1][i][j-1]) + a[i][j] ;
            }
            for(int j = m ; j >=1 ; j--)
            {
                dp[4][i][j] = max(dp[4][i-1][j] , dp[4][i][j+1]) + a[i][j] ;
            }
        }
        for(int i = n ; i >= 1 ; i--)
        {
            for(int j = 1 ; j <= m ; j++)
            {
                dp[2][i][j] = max(dp[2][i+1][j] , dp[2][i][j-1]) + a[i][j] ;
            }
            for(int j = m ; j >=1 ; j--)
            {
                dp[3][i][j] = max(dp[3][i+1][j] , dp[3][i][j+1]) + a[i][j] ;
                //cout<<dp[3][i][j]<<endl;
            }

        }
        LL ans = 0 ;
        //不用管边界的情况，都是0，加上也是可以的
        for(int i = 2 ; i < n ; i++)
        {
            for(int j = 2 ; j < m ; j++)
            {
                //枚举每个点当作唯一的交点
                //只有两种情况，1,3角横着或者竖着穿过点(i,j),这样才能保证只有一个交点
                LL num1 = (dp[1][i-1][j]+dp[3][i+1][j]) + (dp[2][i][j-1]+dp[4][i][j+1]);
                //cout<<" "<<dp[1][i-1][j]<<" "<<dp[3][i+1][j]<<" "<<dp[2][i][j-1]<<" "<<dp[4][i][j+1]<<endl;
                //cout<<num1<<endl;
                ans = max(ans,num1);
                LL num2 = (dp[1][i][j-1]+dp[3][i][j+1]) + (dp[2][i+1][j]+dp[4][i-1][j]);
                ans = max(ans,num2);
                //cout<<" "<<dp[1][i][j-1]<<" "<<dp[3][i][j+1]<<" "<<dp[2][i+1][j]<<" "<<dp[3][i-1][j]<<endl;
                //cout<<num2<<endl;
            }
        }
        printf("%I64d\n",ans);
    }
    return 0;
}