【动态规划】Mathematical Curse

【来源】：2018年焦作网络赛B

【题意】：

　　有n个数字，有m个符号运算。通过不回头（即选取m个数有顺序可言），消除巫术的，并达到最大的价值。

　　其实意思就是在数组里选取一段子序列，然后进行m次加减乘除的运算。最后使答案最大化。

【思路】：

　　考虑DP，我们考虑加减时只需要考虑最大值即可，但是乘除两个运算的加入就会使这个题目变得复杂了。

　　然后我们需要的记录最大值和最小值，因为每一个值可能是从最大值转移过来，也有可能最小值转移过来的。

　　所以需要同时记录。

【注意】：

　　1、记得初始化（多组数据）

　　2、如果直接转移会耗费O(n^2)，其实我们只是关心前i个里面获取的最大值，所以我们需要压缩，从前一个数字的暂存值进行更新。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e4+10;
const int M = 6;
const ll inf = 0x7fffffffffffffff;
ll dp[N][M][2]; //0_ 最小值 ，1 最大值
ll a[N];
int main(){
    int T;
    int n,m,k;
    char opt[M] ;
    for( scanf("%d",&T) ; T ;T-- ){
        scanf("%d%d%d",&n,&m,&k);
        for(int i=1;i<=n;i++)   scanf("%lld",&a[i]);
        scanf("%s",opt+1);

        for(int i=0;i<=n;i++){
            for(int j=0;j<=m;j++){
                dp[i][j][0] =  inf ;
                dp[i][j][1] = -inf ;
            }
        }

        for(int i=0;i<=n;i++){
            dp[i][0][0] = dp[i][0][1] = k;
        }


        for(int j=1;j<=m;j++){
            for(int i=1;i<=n;i++){
                if( i > j ){
                    dp[i][j][0] = dp[i-1][j][0];
                    dp[i][j][1] = dp[i-1][j][1];
                }

                if( opt[j] =='+'){
                    dp[i][j][0] = min( dp[i][j][0] , dp[i-1][j-1][0] + a[i] );
                    dp[i][j][0] = min( dp[i][j][0] , dp[i-1][j-1][1] + a[i] );

                    dp[i][j][1] = max( dp[i][j][1] , dp[i-1][j-1][0] + a[i] );
                    dp[i][j][1] = max( dp[i][j][1] , dp[i-1][j-1][1] + a[i] );
                }else if( opt[j] == '-'){
                    dp[i][j][0] = min( dp[i][j][0] , dp[i-1][j-1][0] - a[i] );
                    dp[i][j][0] = min( dp[i][j][0] , dp[i-1][j-1][1] - a[i] );

                    dp[i][j][1] = max( dp[i][j][1] , dp[i-1][j-1][0] - a[i] );
                    dp[i][j][1] = max( dp[i][j][1] , dp[i-1][j-1][1] - a[i] );
                }else if( opt[j] == '*' ){
                    dp[i][j][0] = min( dp[i][j][0] , dp[i-1][j-1][0] * a[i] );
                    dp[i][j][0] = min( dp[i][j][0] , dp[i-1][j-1][1] * a[i] );

                    dp[i][j][1] = max( dp[i][j][1] , dp[i-1][j-1][0] * a[i] );
                    dp[i][j][1] = max( dp[i][j][1] , dp[i-1][j-1][1] * a[i] );
                }else{
                    dp[i][j][0] = min( dp[i][j][0] , dp[i-1][j-1][0] / a[i] );
                    dp[i][j][0] = min( dp[i][j][0] , dp[i-1][j-1][1] / a[i] );

                    dp[i][j][1] = max( dp[i][j][1] , dp[i-1][j-1][0] / a[i] );
                    dp[i][j][1] = max( dp[i][j][1] , dp[i-1][j-1][1] / a[i] );
                }
            }
        }

        printf("%lld
",dp[n][m][1]);
    }
    return 0 ;
}