第十一节 动态规划 - 3

区间 DP

A. 能量项链

题目描述

在 Mars 星球上，每个 Mars 人都随身佩带着一串能量项链。在项链上有 \(N\) 颗能量珠。能量珠是一颗有头标记与尾标记的珠子，这些标记对应着某个正整数。并且，对于相邻的两颗珠子，前一颗珠子的尾标记一定等于后一颗珠子的头标记。因为只有这样，通过吸盘（吸盘是 Mars 人吸收能量的一种器官）的作用，这两颗珠子才能聚合成一颗珠子，同时释放出可以被吸盘吸收的能量。如果前一颗能量珠的头标记为 \(m\)，尾标记为 \(r\)，后一颗能量珠的头标记为 \(r\)，尾标记为 \(n\)，则聚合后释放的能量为 \(m \times r \times n\)（Mars 单位），新产生的珠子的头标记为 \(m\)，尾标记为 \(n\)。

需要时，Mars 人就用吸盘夹住相邻的两颗珠子，通过聚合得到能量，直到项链上只剩下一颗珠子为止。显然，不同的聚合顺序得到的总能量是不同的，请你设计一个聚合顺序，使一串项链释放出的总能量最大。

例如：设 \(N=4\)，\(4\) 颗珠子的头标记与尾标记依次为 \((2,3)(3,5)(5,10)(10,2)\)。我们用记号 \(\oplus\) 表示两颗珠子的聚合操作，\((j \oplus k)\) 表示第 \(j,k\) 两颗珠子聚合后所释放的能量。则第 \(4\)，\(1\) 两颗珠子聚合后释放的能量为：

\((4 \oplus 1)=10 \times 2 \times 3=60\)。

这一串项链可以得到最优值的一个聚合顺序所释放的总能量为：

\((((4 \oplus 1) \oplus 2) \oplus 3)=10 \times 2 \times 3+10 \times 3 \times 5+10 \times 5 \times 10=710\)。

输入格式

第一行是一个正整数 \(N\)（\(4 \le N \le 100\)），表示项链上珠子的个数。第二行是 \(N\) 个用空格隔开的正整数，所有的数均不超过 \(1000\)。第 \(i\) 个数为第 \(i\) 颗珠子的头标记（\(1 \le i \le N\)），当 \(i<N\) 时，第 \(i\) 颗珠子的尾标记应该等于第 \(i+1\) 颗珠子的头标记。第 \(N\) 颗珠子的尾标记应该等于第 \(1\) 颗珠子的头标记。

至于珠子的顺序，你可以这样确定：将项链放到桌面上，不要出现交叉，随意指定第一颗珠子，然后按顺时针方向确定其他珠子的顺序。

输出格式

一个正整数 \(E\)（\(E\le 2.1 \times 10^9\)），为一个最优聚合顺序所释放的总能量。

样例输入 #1

4
2 3 5 10

样例输出 #1

710

提示

NOIP 2006 提高组 第一题

点击查看代码

#include<iostream>
using namespace std;

int n, a[205];
long long dp[405][405];

int main() {
    cin >> n;
    for(int i = 1; i <= n; i ++) {
        cin >> a[i];
        a[i + n] = a[i];
    }
    for(int len = 2; len <= n + 1; len ++)
        for(int l = 1; l + len - 1 <= 2 * n; l ++) {
            int r = l + len - 1;
            for(int k = l + 1; k <= l + len - 2; k ++) 
                dp[l][r] = max(dp[l][r], dp[l][k] + dp[k][r] + (long long)(a[l] * a[k] * a[r]));
        }
    long long res = 0;
    for(int i = 1; i <= n; i ++) res = max(res, dp[i][n + i]);
    cout << res << endl;
    return 0;
}
编译结果
compiled successfully
time: 5ms, memory: 3920kb, score: 100, status: Accepted
> test 1: time: 1ms, memory: 3472kb, points: 10, status: Accepted
> test 2: time: 0ms, memory: 3392kb, points: 10, status: Accepted
> test 3: time: 0ms, memory: 3448kb, points: 10, status: Accepted
> test 4: time: 1ms, memory: 3436kb, points: 10, status: Accepted
> test 5: time: 1ms, memory: 3516kb, points: 10, status: Accepted
> test 6: time: 0ms, memory: 3692kb, points: 10, status: Accepted
> test 7: time: 1ms, memory: 3604kb, points: 10, status: Accepted
> test 8: time: 0ms, memory: 3556kb, points: 10, status: Accepted
> test 9: time: 1ms, memory: 3816kb, points: 10, status: Accepted
> test 10: time: 0ms, memory: 3920kb, points: 10, status: Accepted

B. 开心消消乐

题目描述

\(A\) 酱最近在玩开心消消乐，由于是异次元的游戏，所以规则可能和地球上的有所不同。

开心消消乐是一个在大圆环上进行的游戏，环上有若干个宝石，每颗宝石都有自己的积分,由于消消乐是一个三消游戏，我们每次可以挑选其中一个宝石消去，消去宝石的积分为他的积分和左右相邻宝石积分的乘积，比如下左图中，消去 \(1\) 的积分就是 \(1 \times 2 \times 4\)，如果剩下最后 \(2\) 颗宝石，比如下图中，消去 \(3\) 的积分是\(4 \times 3 \times 4\),如果剩下最后 \(1\) 颗宝石，消去的积分就是他自身的分数。

现在A酱为了通过这一关，需要将宝石消除完，并且获得的积分越大，她的游戏排名就越高，她想请你帮她算算最大得分是多少。

输入数据

共两行，

第一行一个正整数n（1<=n<=500)表示宝石数量

第二行n个正整数ai（1<=i<=n,1<=ai<=100),表示每颗宝石的积分。

输出数据

一行，一个正整数表示获得的最大积分

输入样例1

4
1 2 3 4

输出样例1

84

输入样例2

10
45 29 8 3 32 54 88 68 70 83

输出样例2

2304371

点击查看代码

#include<iostream>
using namespace std;

int n, a[1005];
long long dp[2005][2005];

int main() {
    cin >> n;
    for(int i = 1; i <= n; i ++) {
        cin >> a[i];
        a[i + n] = a[i];
    }
    for(int i = 1; i <= 2 * n; i ++) dp[i][i] = a[i - 1] * a[i] * a[i + 1];
    for(int len = 2; len <= n; len ++) {
        for(int l = 1; l + len - 1 <= 2 * n; l ++) {
            int r = l + len - 1;
            for(int k = l; k <= r; k ++) {
                if(len == n) dp[l][r] = max(dp[l][r], dp[l][k - 1] + dp[k + 1][r] + a[k]);
                else dp[l][r] = max(dp[l][r], dp[l][k - 1] + dp[k + 1][r] + (long long)(a[l - 1] * a[k] * a[r + 1]));
            }
        }
    }
    long long res = 0;
    for(int i = 0; i <= 2 * n; i ++) 
        for(int j = 0; j <= 2 * n; j ++)
            res = max(res, dp[i][j]);
    cout << res << endl;
    return 0;
}
编译结果
compiled successfully
time: 398ms, memory: 16740kb, score: 100, status: Accepted
> test 1: time: 2ms, memory: 6152kb, points: 10, status: Accepted
> test 2: time: 47ms, memory: 12396kb, points: 10, status: Accepted
> test 3: time: 1ms, memory: 3828kb, points: 10, status: Accepted
> test 4: time: 110ms, memory: 16740kb, points: 10, status: Accepted
> test 5: time: 0ms, memory: 6128kb, points: 10, status: Accepted
> test 6: time: 12ms, memory: 10320kb, points: 10, status: Accepted
> test 7: time: 1ms, memory: 3516kb, points: 10, status: Accepted
> test 8: time: 61ms, memory: 14556kb, points: 10, status: Accepted
> test 9: time: 90ms, memory: 14556kb, points: 10, status: Accepted
> test 10: time: 74ms, memory: 14496kb, points: 10, status: Accepted

C. 奶牛的零食

题目描述

约翰经常给产奶量高的奶牛发特殊津贴，于是很快奶牛们拥有了大笔不知该怎么花的钱。为此，约翰购置了 \(N\) 份美味的零食来卖给奶牛们。每天约翰售出一份零食。当然约翰希望这些零食全部售出后能得到最大的收益，这些零食有以下这些有趣的特性：

零食按照 \(1,…,N\) 编号，它们被排成一列放在一个很长的盒子里。盒子的两端都有开口，约翰每天可以从盒子的任一端取出最外面的一个。

与美酒与好吃的奶酪相似，这些零食储存得越久就越好吃。当然，这样约翰就可以把它们卖出更高的价钱。

每份零食的初始价值不一定相同。约翰进货时，第i份零食的初始价值为 \(V_i\)（\(1 \le V \le 1000\)）。

第i份零食如果在被买进后的第 \(a\) 天出售，则它的售价是 \(V_i \times a\)。

\(V_i\) 的是从盒子顶端往下的第i份零食的初始价值。约翰告诉了你所有零食的初始价值，并希望你能帮他计算一下，在这些零食全被卖出后，他最多能得到多少钱。

输入格式

第一行一个整数 \(t\)，代表有 \(t\) 组样例，\(1 \le t \le 50\)

每组样例:

第一行一个整数 \(N\)，代表有 \(N\) 件零食，

接下来 \(2 ~ N + 1\) 行，第 \(i + 1\) 行代表第 \(i\) 份零食的价值 \(V_i\)

保证 \(sum(N) \le 2000\)

输出格式

每组样例输出约翰最多能卖出多少钱

样例输入 #1

2
5
1
3
1
5
2
2
8
9

样例输出 #1

43
26

提示

第一组样例有 \(5\) 件零食，第一天约翰可以选择第 \(1\) 件或第 \(5\) 件

最后约翰卖出零食(零食的价值为 \(1,3,1,5,2\)）的顺序可以是 \(1,5,2,3,4\)，也就是先卖第 \(1\) 件，再卖第 \(5\) 件，再卖第 \(2\) 件，再卖第 \(3\) 件，再卖第 \(4\) 件。总和 \(= 1 \times 1 + 2 \times 2 + 3 \times 3 + 4 \times 1 + 5 \times 5 = 43\).

第二组样例有 \(2\) 件零食。

点击查看代码

#include<iostream>
#include<cmath>
#include<string.h>
using namespace std;

int T, n, dp[2005][2005], v[2005];

int main() {
    scanf("%d", &T);
    while(T --) {
        scanf("%d", &n);
        for(int i = 1; i <= n; i ++) scanf("%d", &v[i]);
        for(int i = 1; i <= n; i ++) dp[i][i] = v[i] * n;
        for(int len = 2; len <= n; len ++)
            for(int l = 1; l <= n; l ++) {
                int r = l + len - 1;
                if(r > n) break;
                dp[l][r] = max(dp[l][r - 1] + v[r] * (n - len + 1), dp[l + 1][r] + v[l] * (n - len + 1));
            }
        printf("%d\n", dp[1][n]);
    }
    return 0;
}
编译结果
compiled successfully
time: 14ms, memory: 16892kb, score: 100, status: Accepted
> test 1: time: 1ms, memory: 3576kb, points: 10, status: Accepted
> test 2: time: 0ms, memory: 3788kb, points: 10, status: Accepted
> test 3: time: 2ms, memory: 6816kb, points: 10, status: Accepted
> test 4: time: 2ms, memory: 4428kb, points: 10, status: Accepted
> test 5: time: 0ms, memory: 3964kb, points: 10, status: Accepted
> test 6: time: 1ms, memory: 3748kb, points: 10, status: Accepted
> test 7: time: 1ms, memory: 15936kb, points: 10, status: Accepted
> test 8: time: 1ms, memory: 11532kb, points: 10, status: Accepted
> test 9: time: 3ms, memory: 16888kb, points: 10, status: Accepted
> test 10: time: 3ms, memory: 16892kb, points: 10, status: Accepted