石子合并 不同复杂度的做法

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堆石子的数量，计算最小合并代价。

当n小于1000的时候可以用朴素的区间dp暴力A之

#include<bits/stdc++.h>
#define maxn 1005
using namespace std;
int a[maxn],sum[maxn],dp[maxn][maxn];
int main(){
    int n,loop,cnt=1;
    while(scanf("%d",&n)!=EOF){
        sum[0]=0;
        for(int i=1;i<=n;++i){
            scanf("%d",&a[i]);
            sum[i]=sum[i-1]+a[i];
        }
        memset(dp,INF,sizeof(dp));
        for(int i=1;i<=n;++i)dp[i][i]=0;
        for(int l=2;l<=n;++l)
            for(int i=1;i+l-1<=n;++i){
                int j=i+l-1;
                for(int k=i+1;k<=j;++k)
                    dp[i][j]=min(dp[i][k-1]+dp[k][j]+sum[j]-sum[i-1],dp[i][j]);
            }
    cout<<dp[1][n]<<'\12';
    }
    return 0;
}
        

当大于1000的时候可以采用四边形不等式优化让复杂度降到n*n 这里51nod的1022题 

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堆石子的数量，计算最小合并代价。

利用四边形不等式进行优化

#include<bits/stdc++.h>
using namespace std;
#define N 2009
int n,f[N][N]={0},a[N][N]={0};
int s[N][N];
int main(){
    memset(f,1,sizeof(f));
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%d",&a[i][i]);
        a[n+i][n+i] = a[i][i];
    }
    for(int i=0;i<n*2;i++){
        s[i][i] = i;
        f[i][i] = 0;
    }
    for(int i=0;i<n*2-1;i++)
        for(int j=i+1;j<n*2-1;j++)
          a[i][j] = a[i][j-1] + a[j][j];
    for(int l=1;l<n;l++){
        for(int i=0;i+l<n*2-1;i++){
            int j = i+l;
            for(int k=s[i][j-1];k<=s[i+1][j];k++){
                if(f[i][j] > a[i][j]+f[i][k]+f[k+1][j]){
                    f[i][j] = a[i][j]+f[i][k]+f[k+1][j];
                    s[i][j] = k;
                }
            }
        }
    }
    int ans = f[0][n-1];
    for(int i=1;i<n;i++)
        if(ans > f[i][i+n-1])
            ans = f[i][i+n-1];
    printf("%d\n",ans);
    return 0;
}

最后当n特别大的时候比如5w，这时候采用 GarsiaWachs算法

设序列是stone[]，从左往右，找一个满足stone[k-1] <= stone[k+1]的k，找到后合并stone[k]和stone[k-1]，再从当前位置开始向左找最大的j，使其满足stone[j] > stone[k]+stone[k-1]，插到j的后面就行。一直重复，直到只剩下一堆石子就可以了。在这个过程中，可以假设stone[-1]和stone[n]是正无穷的。

举个例子：

186 64 35 32 103

因为35<103，所以最小的k是3，我们先把35和32删除，得到他们的和67，并向前寻找一个第一个超过67的数，把67插入到他后面，得到：186 67 64 103,现在由5个数变为4个数了，继续：186 131 103，现在k=2（别忘了，设A[-1]和A[n]等于正无穷大）234 186，最后得到420。最后的答案呢？就是各次合并的重量之和，即420+234+131+67=852。

基本思想是通过树的最优性得到一个节点间深度的约束，之后证明操作一次之后的解可以和原来的解一一对应，并保证节点移动之后他所在的深度不会改变。具体实现这个算法需要一点技巧，精髓在于不停快速寻找最小的k，即维护一个“2-递减序列”朴素的实现的时间复杂度是O(n*n)，但可以用一个平衡树来优化，使得最终复杂度为O(nlogn)。

#include <cstdio>
#include <iostream>
#include <algorithm>
#define maxn 55555
using namespace std;
int a[maxn];
int t;
long long ans;
void doit(int x){
    int tmp=a[x]+a[x-1];
    ans+=tmp;
    for(int i=x;i<t-1;++i)
        a[i]=a[i+1];
    t--;
    int j;
    for(j=x-1;j>0&&a[j-1]<tmp;j--)
        a[j]=a[j-1];
    a[j]=tmp;
    while(j>=2&&a[j]>=a[j-2]){
        int tmp=t-j;
        doit(j-1);
        j=t-tmp;
    }
}
int main(){
    int n,loop,cnt=1;
    while(scanf("%d",&n)&&n){
        for(int i=0;i<n;++i)scanf("%d",&a[i]);
        t=1,ans=0;
        for(int i=1;i<n;++i){
            a[t++]=a[i];
            while(t>=3&&a[t-3]<=a[t-1])doit(t-2);
        }
        while(t>1)doit(t-1);
        cout<<ans<<'\12';
    }
    return 0;