简单递推 - 动态规划 - LightOJ - 1004 - Monkey Banana Problem_猴子吃香蕉”问题动态规划时间复杂度-优快云博客

本文链接：https://blog.youkuaiyun.com/FlushHip/article/details/78412740

本文介绍了一道经典的动态规划问题——求菱形地图中从顶点到底边的最大数字和。通过递推型动态规划算法并采用滚动数组优化内存使用，实现高效的解决方案。

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

题目链接：[点这儿].

题意：

一个菱形地图，每个格子有数字，问你从最上面一个格子走到最下面一个格子经过的数字加起来最大是多少，向下走的时候只能走下面相邻的两个格子.

解析：

简单的递推型动态规划，状态转移方程为：
$d p i, j = a r r i, j + {m a x (j < a r r i - 1 . s i z e ? d p i - 1, j : 0, j - 1 < 0 ? 0 : d p i - 1, j - 1) m a x (d p i - 1, j, d p i - 1, j + 1) i < n i > = n$ $dp_{i,j}=arr_{i,j}+\left \{ \begin{array}{ll} & max(j < arr_{i-1}.size ?\quad dp_{i-1,j}: 0,\quad j - 1 < 0 ?\quad 0 : dp_{i-1,j-1}) &i < n\\ &max(dp_{i-1,j},\quad dp_{i-1,j+1}) & i >=n \end{array} \right.$
这种由上往下递推的动态规划，一般可以用滚动数组来优化内存空间.

代码：

#include <bits/stdc++.h>

using namespace std;

int main()
{
    int T, K = 1;
    for (scanf("%d", &T); T--; K++) {
        int n, x;
        scanf("%d", &n);

        vector<vector<int> > arr(2), dp(2, vector<int>(n));
        arr[0].push_back((scanf("%d", &x), x));
        dp[0][0] = arr[0][0];
        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= i; j++)
                arr[i % 2].push_back((scanf("%d", &x), x));
            for (int j = 0; j < arr[i % 2].size(); j++)
                dp[i % 2][j] = arr[i % 2][j] +
                    max(j < arr[(i - 1) % 2].size() ? dp[(i - 1) % 2][j] : 0,
                    j - 1 < 0 ? 0 : dp[(i - 1) % 2][j - 1]);
            arr[(i - 1) % 2].clear();
        }
        for (int i = n; i < 2 * n - 1; i++) {
            for (int j = 2 * n - i - 1; j > 0; j--)
                arr[i % 2].push_back((scanf("%d", &x), x));
            for (int j = 0; j < arr[i % 2].size(); j++)
                dp[i % 2][j] = arr[i % 2][j] + max(dp[(i - 1) % 2][j], dp[(i - 1) % 2][j + 1]);
            arr[(i - 1) % 2].clear();
        }

        printf("Case %d: %d\n", K, dp[(2 * n - 2) % 2][0]);
    }
    return 0;
}