51nod - 1022【四边形不等式优化DP】

1022 石子归并 V2

基准时间限制：1 秒 空间限制：131072 KB 分值: 160 难度：6级算法题

收藏

关注

N堆石子摆成一个环。现要将石子有次序地合并成一堆。规定每次只能选相邻的2堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的代价。计算将N堆石子合并成一堆的最小代价。

 

例如： 1 2 3 4，有不少合并方法

1 2 3 4 => 3 3 4(3) => 6 4(9) => 10(19)

1 2 3 4 => 1 5 4(5) => 1 9(14) => 10(24)

1 2 3 4 => 1 2 7(7) => 3 7(10) => 10(20)

 

括号里面为总代价可以看出，第一种方法的代价最低，现在给出n堆石子的数量，计算最小合并代价。

Input

第1行：N（2 <= N <= 1000)
第2 - N + 1：N堆石子的数量（1 <= A[i] <= 10000)

Output

输出最小合并代价

Input示例

4
1
2
3
4

Output示例

19

题解：

设dp[i][j]表示区间 i -> j的最低代价; 则dp[i][j]  = min(dp[i][k], dp[k+1][j]) + sum[j]-sum[i-1]; ( i: n->1, j: i -> n);

需要 n^3 的复杂度，利用四边形定理来优化，环状可以*2处理成线性。按照我的递推方向求dp[i][j]的时候，所有的左边界大于i，右边界小于j的区间都被更新过且是最优。

因此在求s[i][j]的时候，从 s[i][j-1] ~ s[i+1][j] 来进行决策更新。另一种递推方向是可以写成 s[i-1][j] ~ s[i][j+1]的，取决自己的递推方向。

关于s函数的单调性需要再学习。（满足化学主族元素的非金属性，即 左 -> 右，上 -> 下，越来越大）

代码：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <bitset>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <list>
#include <set>
#include <map>
#define rep(i,a,b) for(int i = a;i <= b;++ i)
#define per(i,a,b) for(int i = a;i >= b;-- i)
#define mem(a,b) memset((a),(b),sizeof((a)))
#define FIN freopen("in.txt","r",stdin)
#define FOUT freopen("out.txt","w",stdout)
#define IO ios_base::sync_with_stdio(0),cin.tie(0)
#define mid ((l+r)>>1)
#define ls (id<<1)
#define rs ((id<<1)|1)
#define N 2010
#define INF 0x3f3f3f3f
#define INFF ((1LL<<62)-1)
typedef long long LL;
using namespace std;

int n, m, T, c[N], s[N][N], sum[N], dp[N][N];
int main()
{IO;
    //FIN;
    while(cin >> n){
        sum[0] = 0;
        rep(i, 1, n){ 
            cin >> c[i]; 
            sum[i] = sum[i-1] + c[i]; 
        }
        rep(i, 1, n){
            c[i+n] = c[i];
            sum[i+n] = sum[i+n-1]+c[i+n];
        }

        mem(dp, 0);
        per(i, n*2, 1){
            rep(j, i, n*2){
                if(i == j)    { s[i][j] = i; continue; }
                dp[i][j] = INF;
                LL res = sum[j]-sum[i-1];
                rep(k, s[i][j-1], s[i+1][j]){
                    if(dp[i][k]+dp[k+1][j]+res < dp[i][j]){
                        dp[i][j] = dp[i][k]+dp[k+1][j]+res;
                        s[i][j] = k;
                    }
                }
            }
        }
        int ans = INF;
        rep(i, 1, n)    ans = min(ans, dp[i][i+n-1]);
        cout << ans << endl;
    }
    return 0;
}