Description
在一个操场上摆放着一排N堆石子。现要将石子有次序地合并成一堆。规定每次只能选相邻的2堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。
试设计一个算法，计算出将N堆石子合并成一堆的最小得分.
Input
第一行是一个数N。以下N行每行一个数A，表示石子数目。
Output
共一个数，即N堆石子合并成一堆的最小得分。
Sample Input
4
1
1
1
1
Sample Output
8
HINT
对于 100% 的数据，1≤N≤40000
对于 100% 的数据，1≤A≤200
解题思路：题目很简单，但是没办法用常规的区间dp来做 （n^3) 这时候我们需要优化一下。
GarsiaWachs算法
平行四边形优化区间dp
四边形不等式优化动态规划原理:
1.当决策代价函数w[i][j]满足w[i][j]+w[i’][j’]<=w[I;][j]+w[i][j’](i<=i’<=j<=j’)时,称w满足四边形不等式.当函数w[i][j]满足w[i’][j]<=w[i][j’] i<=i’<=j<=j’)时,称w关于区间包含关系单调.
2.如果状态转移方程m为
且决策代价w满足四边形不等式的单调函数(可以推导出m亦为满足四边形不等式的单调函数),则可利用四边形不等式推出最优决策s的单调函数性,从而减少每个状态的状态数,将算法的时间复杂度由原来的O(n^3)降低为O(n^2).方法是通过记录子区间的最优决策来减少当前的决策量.令:
s[i][j]=max{k | ma[i][j] = m[i][k-1] + m[k][j] + w[i][j]}
由于决策s具有单调性,因此状态转移方程可修改为:
证明过程: (转载)
设m[i,j]表示动态规划的状态量。
m[i,j]有类似如下的状态转移方程：
m[i,j]=opt{m[i,k]+m[k,j]}(i≤k≤j)
如果对于任意的a≤b≤c≤d，有m[a,c]+m[b,d]≤m[a,d]+m[b,c]，那么m[i,j]满足四边形不等式。
以上是适用这种优化方法的必要条件
对于一道具体的题目，我们首先要证明它满足这个条件，一般来说用数学归纳法证明，根据题目的不同而不同。
通常的动态规划的复杂度是O(n3)，我们可以优化到O(n2)
设s[i,j]为m[i,j]的决策量，即m[i,j]=m[i,s[i,j]]+m[s[i,j]+j]
我们可以证明，s[i,j-1]≤s[i,j]≤s[i+1,j] （证明过程见下）
那么改变状态转移方程为：
m[i,j]=opt{m[i,k]+m[k,j]} (s[i,j-1]≤k≤s[i+1,j])
复杂度分析：不难看出，复杂度决定于s的值，以求m[i,i+L]为例，
(s[2,L+1]-s[1,L])+(s[3,L+2]-s[2,L+1])…+(s[n-L+1,n]-s[n-L,n-1])=s[n-L+1,n]-s[1,L]≤n
所以总复杂度是O(n2)
对s[i,j-1]≤s[i,j]≤s[i+1,j]的证明：
设mk[i,j]=m[i,k]+m[k,j]，s[i,j]=d
对于任意k<d，有mk[i,j]≥md[i,j]（这里以m[i,j]=min{m[i,k]+m[k,j]}为例,max的类似），接下来只要证明mk[i+1,j]≥md[i+1,j]，那么只有当s[i+1,j]≥s[i,j]时才有可能有ms[i+1,j][i+1,j]≤md[i+1,j]
(mk[i+1,j]-md[i+1,j]) - (mk[i,j]-md[i,j])
=(mk[i+1,j]+md[i,j]) - (md[i+1,j]+mk[i,j])
=(m[i+1,k]+m[k,j]+m[i,d]+m[d,j]) - (m[i+1,d]+m[d,j]+m[i,k]+m[k,j])
=(m[i+1,k]+m[i,d]) - (m[i+1,d]+m[i,k])
∵m满足四边形不等式，∴对于i<i+1≤k<d有m[i+1,k]+m[i,d]≥m[i+1,d]+m[i,k]
∴(mk[i+1,j]-md[i+1,j])≥(mk[i,j]-md[i,j])≥0
∴s[i,j]≤s[i+1,j]，同理可证s[i,j-1]≤s[i,j]
证毕
扩展：
以上所给出的状态转移方程只是一种比较一般的，其实，很多状态转移方程都满足四边形不等式优化的条件。
解决这类问题的大概步骤是：
0.证明w满足四边形不等式，这里w是m的附属量，形如m[i,j]=opt{m[i,k]+m[k,j]+w[i,j]}，此时大多要先证明w满足条件才能进一步证明m满足条件
1.证明m满足四边形不等式
2.证明s[i,j-1]≤s[i,j]≤s[i+1,j]
设序列是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<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn=4e4+10;
int n,m,num[maxn],t,ans;
void combine(int k){
int tmp=num[k]+num[k-1];
ans+=tmp;
for(int i=k;i<t-1;i++)
num[i]=num[i+1];
t--;
int j=0;
for(j=k-1;j>0&&num[j-1]<tmp;j--){
num[j]=num[j-1];
}
num[j]=tmp;
while(j>=2&&num[j]>=num[j-2]){
int d=t-j;
combine(j-1);
j=t-d;
}
}
int main(){
int i,j;
while(scanf("%d",&n)!=EOF){
for(i=0;i<n;i++) scanf("%d",&num[i]);
t=1;ans=0;
for(i=1;i<n;i++){
num[t++]=num[i];
while(t>=3&&num[t-3]<=num[t-1]){
combine(t-2);
}
}
while(t>1) combine(t-1);
printf("%d\n",ans);
}
return 0;
}