洛谷P4342/poj1179 Polygon

看到这种拆边成链的问题,第一反应就是区间dp.

这一题的难点在状态转移上。单纯储存最大值不能满足dp中最优子结构的性质。

从转移角度入手，发现最大值的来源可能是两个最大值相加，相乘，两个最小值的相乘（不过把这个最小值相乘的去掉好像对答案没有什么影响）；

最小值的来源可能是两个最小值相加，相乘，或者最大值和最小值相乘（正负得负）。

根据这个想法，不难想出用 f[ i ][ j ][ 0 / 1 ]储存从 i 到 j 的最大值与最小值.

最后，把链拆开复制一倍，跑一下区间dp就可以在O(N³)的时间内求出答案了!

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
const int MAXN = 55;
const int INF = 0x3f3f3f3f;

int N;
int f[MAXN * 2][MAXN * 2][2];//1->max, 0->min
int W[MAXN * 2], opt[MAXN * 2];
//opt : 1.opt[i]->opt between i and i + 1;
//        2.0->'+', 1->'*';


int main()
{
    //freopen("p4342.in", "r", stdin);
    scanf("%d", &N);

    char ch;
    for(int i = 1; i <= N * 2; i++)
    {
        if(i % 2 == 1)
        {
            scanf(" %c", &ch);
            opt[i / 2] = ch == 'x';
        }
        else
            scanf(" %d", &W[i / 2]);
    }

    for(int i = N + 1; i <= 2 * (N + 1); i++)
    {
        W[i] = W[i - N];
        opt[i - 1] = opt[i - N - 1];
    }

    //for(int i = 1; i <= 2 * N; i++)
    //    cout<<W[i]<<" ";

    for(int i = 1; i <= 2 * N; i++)
        for(int j = 1; j <= 2 * N; j++)
            f[i][j][0] = INF, f[i][j][1] = -INF;

    for(int i = 1; i <= 2 * N; i++)
        f[i][i][1] = f[i][i][0] = W[i];

    for(int len = 2; len <= N; len++)
        for(int l = 1; l <= (2 * N - len + 1); l++)
        {
            int r = l + len - 1;
            for(int k = l; k < r; k++)
            {
                if(opt[k] == 1)
                {
                    f[l][r][0] = min(f[l][k][0] * f[k + 1][r][1], f[l][r][0]);
                    f[l][r][0] = min(f[l][k][1] * f[k + 1][r][0], f[l][r][0]);
                    f[l][r][0] = min(f[l][k][0] * f[k + 1][r][0], f[l][r][0]);
                    f[l][r][0] = min(f[l][k][1] * f[k + 1][r][1], f[l][r][0]);

                    f[l][r][1] = max(f[l][k][0] * f[k + 1][r][0], f[l][r][1]);
                    f[l][r][1] = max(f[l][k][1] * f[k + 1][r][1], f[l][r][1]);
                }
                else
                {
                    f[l][r][0] = min(f[l][k][0] + f[k + 1][r][0], f[l][r][0]);
                    f[l][r][1] = max(f[l][k][1] + f[k + 1][r][1], f[l][r][1]);
                }
            }
        }
                

    int ans = -INF;
    for(int i = 1; i <= N; i++)
        ans = max(ans, f[i][i + N - 1][1]);
    cout<<ans<<endl;
    for(int i = 1; i <= N; i++)
        if(f[i][i + N - 1][1] == ans)
            cout<<i<<" ";
    return 0;
}