石子合并（DP+ 四边形不等式优化）

此类问题如    石子合并问题 和  玲珑OJ 1066 buy candy   

区间DP的典型例题， 状态转移是    dp【i】【j】=min（dp【i】【k】+dp【k+1】【j】+w【i，j】）{ i<=K<=j  }， 这里w【i，j】是合并条件的函数，  O（N^3）的时间复杂度。

有一种情况可以优化为O（N^2）的时间复杂度,

(1)当函数w[i,j]满足w[i,j]+w[i',j']<=w[i',j]+w[i,j'],i<=i'<=j<=j'时，称w满足四边形不等式。

(2)当函数w[i,j]满足w[i’,j]≤w[i,j’],i<=i'<=j<=j' 时称w关于区间包含关系单调。

设s【i，j】是dp【i，j】最优值时的K值。

当求最小值时：

当上面条件成立时，k的范围就可以限制为s【i，j-1】<=k<=【i+1，j】,这样时间复杂度就限制在了n^2.

求最大值时：

条件成立时，状态转移方程就变成了  dp【i】【j】=max（dp【i】【j-1】，dp【i+1】【j】），时间复杂度还是在n^2内。

这里有证明，点这里

这里有石子合并的代码：（参考于http://blog.youkuaiyun.com/Wearry/article/details/52136817）

代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
const int INF = 0x3f3f3f3f;

int n;
int c[maxn], v[maxn], f[2][maxn][maxn], s[2][maxn][maxn];

int Getsum(int l, int r) { return c[r] - c[l-1]; }
void combine() { 
    for(int i=0; i<2*n; i++) 
        for(int j=0; j<2; j++) f[j][i][i] = 0, s[j][i][i] = i;

    for(int len=1; len<n; len++) 
        for(int i=0; i+len<2*n; i++) {
            int j = i + len;
            f[0][i][j] = INF; f[1][i][j] = -INF; 
            for(int k=s[0][i][j-1]; k<=s[0][i+1][j]; k++) {
                if(f[0][i][k-1] + f[0][k][j] + Getsum(i, j) < f[0][i][j]) {
                    f[0][i][j] = f[0][i][k-1] + f[0][k][j] + Getsum(i, j);
                    s[0][i][j] = k;
                }
            }f[1][i][j] = max(f[1][i][j-1], f[1][i+1][j]) + Getsum(i, j);
        }
}           

int main() {
#ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    freopen("ans.txt", "w", stdout);
#endif
    scanf("%d", &n);
    for(int i=0; i<n; i++) {
        scanf("%d", &v[i]);
        v[i+n] = v[i];
    }

    c[0] = v[0];
    for(int i=1; i<2*n; i++) c[i] = c[i-1] + v[i];

    combine();

    int Min = INF, Max = -INF;
    for(int i=0; i<=n; i++) Min = min(Min, f[0][i][i+n-1]);
    for(int i=0; i<=n; i++) Max = max(Max, f[1][i][i+n-1]);
    cout << Min << endl << Max << endl;
    return 0;
}

这里还有玲珑OJ 1066的代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <stack>
#include <map>
#include <set>
#include <vector>
#include <queue>
#define mem(p,k) memset(p,k,sizeof(p));
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define inf 0x6fffffff
#define LL long long
#define MAXN 20000
using namespace std;
LL a[1100],b[10],dp[1100][1100],s[1100][1100],p[1100];
LL ss(int m,LL x){
    LL ans=0,k=1;
    for(int i=0;i<=m;i++){
            ans+=b[i]*k;
            k*=x;
    }
    return ans;
}
int main(){
    int t;
    cin>>t;
    while(t--){
        int n,m;
        scanf("%d",&n);
        mem(dp,127);
        for(int i=1;i<=n;i++){
            scanf("%d",a+i);
            p[i]=p[i-1]+a[i];
            dp[i][i]=0;
            s[i][i+1]=i;
        }
        scanf("%d",&m);
        for(int i=0;i<=m;i++)scanf("%lld",b+i);

        for(int i=1;i<n;i++){
            dp[i][i+1]=ss(m,p[i+1]-p[i-1]);
        }
        for(int i=n-2;i>=1;i--){
            for(int j=i+2;j<=n;j++){
                LL x=ss(m,p[j]-p[i-1]);
                for(int k=s[i][j-1];k<=s[i+1][j];k++){

                       if(dp[i][j]>dp[i][k]+dp[k+1][j]+x){
                            dp[i][j]=dp[i][k]+dp[k+1][j]+x;
                            s[i][j]=k;
                       }

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