hlg2144两只猴子【dp】

最新推荐文章于 2020-11-24 20:09:07 发布

原创最新推荐文章于 2020-11-24 20:09:07 发布 · 329 阅读

0 ·

CC 4.0 BY-SA版权

两只猴子分别从果园的不同起点出发，一只只能向下或向右移动，另一只只能向上或向右移动，目标是在避开妖怪的同时尽可能多地采摘水果。通过动态规划算法计算两只猴子能够采摘的最大水果数量。

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

两只猴子

Time Limit: 1500 MS

Memory Limit: 32768 K

Total Submit: 2(2 users)

Total Accepted: 2(2 users)

Rating:

Special Judge: No

Description

两只猴子被猴王派去摘水果。

当这两只猴子到果园时，发现混世魔王带着一群妖怪杀了过来。于是，两只猴子打算分开行动，这样既可以逃走，又可以多采水果。

把果园看成n*m矩形，一只猴子从（1，1）出发，它只能向下或向右走；另一只从（n,1)出发，它只能向上或向右走。

由于妖怪们都很严格的执行混世魔王的命令，当它被派去追一只猴子时它不会去追另一只猴子。汗！

它们最多可以带多少水果会去呢？

注：它们有一种可以储存很多东西的法宝。它们走过的地方水果都会被采走。

Input

第一行：整数n ,m （3<=n,m<=500)

接下来输入n行每行m个整数a[i][j] 表示水果的量(0<=a[i][j]<=10)

Output

最多可带多少水果。

Sample Input

3 3

100 100 100

100 1 100

100 100 100

4 3

1 3 1

1 1 1

1 3 3

2 3 4

3 4

1 2 2 2

2 2 3 2

1 1 1 1

Sample Output

801

这个题描述有问题……

这个题原意是给你一个矩阵从左上角到右下角一只猴子走从左下角到右上角一只猴子走问能带走多上

一次枚举每个点作为焦点然后dp来求就可以了

代码：

  1 #include <iostream>
  2 #include <cstdio>
  3 #include <cstring>
  4 using namespace std;
  5 
  6 #define sc scanf
  7 #define pr printf
  8 #define re return
  9 #define me(a, b) memset(a, b, sizeof(a));
 10 #define fr(i, j, k) for(int i = j; i <= k; i++)
 11 
 12 const int maxn = 505;
 13 
 14 int a[maxn][maxn];
 15 int dp[5][maxn][maxn];
 16 
 17 int main() {
 18     int n, m;
 19     while(EOF != sc("%d %d",&n, &m) ) {
 20         fr(i, 1, n) {
 21             fr(j, 1, m) {
 22                 sc("%d",&a[i][j]);
 23             }
 24         }
 25         me(dp, 0);
 26         dp[1][1][1] = a[1][1];
 27         fr(i, 1, n) {
 28             fr(j, 1, m) {
 29                 if(i == 1 && j == 1) continue;
 30                 if(i == 1) {
 31                     dp[1][i][j] = dp[1][i][j - 1] + a[i][j];
 32                     continue;
 33                 }
 34                 if(j == 1) {
 35                     dp[1][i][j] = dp[1][i - 1][j] + a[i][j];
 36                     continue;
 37                 }
 38                 dp[1][i][j] = max(dp[1][i][j], dp[1][i - 1][j] + a[i][j]);
 39                 dp[1][i][j] = max(dp[1][i][j], dp[1][i][j - 1] + a[i][j]);
 40             }
 41         }
 42 
 43         dp[2][n][1] = a[n][1];
 44         for(int i = n; i >= 1; i--) {
 45             for(int j = 1;j <= m; j++) {
 46                 if(i == n && j == 1) continue;
 47                 if(i == n) {
 48                     dp[2][i][j] = dp[2][i][j - 1] + a[i][j];
 49                     continue;
 50                 }
 51                 if(j == 1) {
 52                     dp[2][i][j] = dp[2][i + 1][j] + a[i][j];
 53                     continue;
 54                 }
 55                 dp[2][i][j] = max(dp[2][i][j], dp[2][i][j - 1] + a[i][j]);
 56                 dp[2][i][j] = max(dp[2][i][j], dp[2][i + 1][j] + a[i][j]);
 57 
 58             }
 59         }
 60 
 61         dp[3][1][m] = a[1][m];
 62         fr(i, 1, n) {
 63             for(int j = m; j >= 1; j--) {
 64                 if(i == 1 && j == m) continue;
 65                 if(i == 1) {
 66                     dp[3][i][j] = dp[3][i][j + 1] + a[i][j];
 67                     continue;
 68                 }
 69                 if(j == m) {
 70                     dp[3][i][j] = dp[3][i - 1][j] + a[i][j];
 71                     continue;
 72                 }
 73                 dp[3][i][j] = max(dp[3][i][j], dp[3][i][j + 1] + a[i][j]);
 74                 dp[3][i][j] = max(dp[3][i][j], dp[3][i - 1][j] + a[i][j]);
 75 
 76             }
 77         }
 78 
 79         dp[4][n][m] = a[n][m];
 80         for(int i = n; i >= 1; i--) {
 81             for(int j = m; j >= 1; j--) {
 82                 if(i == n && j == m) continue;
 83                 if(i == n) {
 84                     dp[4][i][j] = dp[4][i][j + 1] + a[i][j];
 85                     continue;
 86                 }
 87                 if(j == m) {
 88                     dp[4][i][j] = dp[4][i + 1][j] + a[i][j];
 89                     continue;
 90                 }
 91                 dp[4][i][j] = max(dp[4][i][j], dp[4][i][j + 1] + a[i][j]);
 92                 dp[4][i][j] = max(dp[4][i][j], dp[4][i + 1][j] + a[i][j]);
 93 
 94             }
 95         }
 96         int ans = 0;
 97         for(int i = 2; i < n; i++) {
 98             for(int j = 2; j < m; j++) {
 99                 ans = max(ans, dp[1][i][j - 1] + dp[2][i + 1][j] + dp[3][i -1][j] + dp[4][i][j + 1] + a[i][j]);
100                 ans = max(ans, dp[2][i][j - 1] + dp[4][i + 1][j] + dp[1][i -1][j] + dp[3][i][j + 1] + a[i][j]);
101             }
102         }
103         pr("%d\n",ans);
104     }
105     return 0;
106 }

View Code