算法竞赛进阶指南 - 区间dp - Polygon 题意+题解

中规中矩的区间dp

题意：给n个数，围成一个封闭图形，n个数之间存在运算符，你可以选择一条边去掉，然后对剩下的这些数和运算符进行运算，求所有情况中最大的结果 和 首先去掉哪些边能够算出这个结果。

很容易想，我选择是最笨的O（N4）算法，很放心，因为即使60^4也不会爆。
定义两个数组，一个存符号，一个存数字，每结束一轮就把数组整体前移一位。
解决了外围的遍历，其他就是很普通的区间dp，但是我还是被坑了一手，因为有乘法，所以要统计最小值相乘，也可能成为最大值。

//加法的转移，第三位1表示最大，0表示最小
dp[j][end][1] = max(dp[j][end][1],dp[j][k][1]+dp[k+1][end][1]);
dp[j][end][0] = min(dp[j][end][0],dp[j][k][0]+dp[k+1][end][0]);

//乘法的转移，因为wa了几发，然后一怒之下我把所有的情况都写了=-=
dp[j][end][1] = max(dp[j][end][1],dp[j][k][1]*dp[k+1][end][1]);
if (dp[j][k][0] < 0 && dp[k+1][end][0] < 0)   // 最小值只有负数相乘才可能最大
     dp[j][end][1] = max(dp[j][end][1],dp[j][k][0]*dp[k+1][end][0]);
 dp[j][end][0] = min(dp[j][end][0],dp[j][k][1]*dp[k+1][end][1]);
 dp[j][end][0] = min(dp[j][end][0],dp[j][k][0]*dp[k+1][end][1]);
 dp[j][end][0] = min(dp[j][end][0],dp[j][k][1]*dp[k+1][end][0]);
 dp[j][end][0] = min(dp[j][end][0],dp[j][k][0]*dp[k+1][end][0]);

#include <iostream>
#include <vector>
#include <algorithm>
#include "string.h"
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 9;
#define mem(x, i) memset(x,i,sizeof x)
ll dp[140][140][2];
char sym[130];
ll num[140];
ll st[141];
int main() {
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
    int n;
    cin >> n;
    for (int i = 1; i <= 2 * n; ++i) {
        if (i % 2 == 1) {
            char c;
            cin >> c;
            if (c == 't')
                sym[(i+1)/2] = '+';
            else
                sym[(i+1)/2] = '*';
        }
        else
        {
            cin >> num[i/2];
        }
    }
    for (int i = 1; i <= n; ++i) {
        mem(dp,-0X3f3f3f3f);
        for (int j = 1; j <= n; ++j) {
            for (int k = 1; k <= n; ++k) {
                dp[j][k][0] = 0x3f3f3f3f;
            }
        }
        for (int j = 1; j <= n; ++j) {
            dp[j][j][1] = num[j];
            dp[j][j][0] = num[j];
//            cout << dp[j][j] << ' ' << sym[j] << ' ';
        }
//        cout << endl;
        for (int len = 1; len <= n; ++len) {
            for (int j = 1; j + len - 1 <= n; ++j) {
                int end = j+ len - 1;
                for (int k = j; k < end; ++k) {
                    if (sym[k+1] == '+')
                    {
                        dp[j][end][1] = max(dp[j][end][1],dp[j][k][1]+dp[k+1][end][1]);
                        dp[j][end][0] = min(dp[j][end][0],dp[j][k][0]+dp[k+1][end][0]);
                    }
                    else
                    {
                        dp[j][end][1] = max(dp[j][end][1],dp[j][k][1]*dp[k+1][end][1]);
                        if (dp[j][k][0] < 0 && dp[k+1][end][0] < 0)
                            dp[j][end][1] = max(dp[j][end][1],dp[j][k][0]*dp[k+1][end][0]);
                        dp[j][end][0] = min(dp[j][end][0],dp[j][k][1]*dp[k+1][end][1]);
                        dp[j][end][0] = min(dp[j][end][0],dp[j][k][0]*dp[k+1][end][1]);
                        dp[j][end][0] = min(dp[j][end][0],dp[j][k][1]*dp[k+1][end][0]);
                        dp[j][end][0] = min(dp[j][end][0],dp[j][k][0]*dp[k+1][end][0]);
                    }
//                    cout << dp[j][end] << endl;
                }
            }
        }
//        cout << endl;
        st[i] = dp[1][n][1];
        int g = num[1];
        for (int j = 1; j < n; ++j) {
            num[j] = num[j+1];
        }
        num[n] = g;
        char c;
        c = sym[1];
        for (int j = 1; j < n; ++j) {
            sym[j] = sym[j+1];
        }
        sym[n] = c;
    }
    ll ma = -9223372036854775800;
    for (int i = 1; i <= n; ++i) {
        ma = max(ma,st[i]);
    }
    cout << ma << endl;
    for (int i = 1; i <= n; ++i) {
        if (ma == st[i])
            cout << i <<' ';
    }
}