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

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]
<<'\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

={0},a

={0};
int s

;
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
是正无穷的。




举个例子：
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
等于正无穷大）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;