HDU 3506(区间dp) 四边形不等式优化

合并石子差不多，题意一样的。

先来一道弱化版

https://www.luogu.org/problemnew/show/P1880

在一个圆形操场的四周摆放N堆石子,现要将石子有次序地合并成一堆.规定每次只能选相邻的2堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。

试设计出1个算法,计算出将N堆石子合并成1堆的最小得分和最大得分.

本题题意和上面一样的

这次变成了猴子聚会了。现在有n只猴子坐成一圈，每只猴子都有交朋友的时间，每次，他只能介绍一只猴子和一只猴子的邻居。如果他介绍A和B，那么每只已经知道猴子A都知道每只猴子B了，这次引入的总时间是所有猴子A和B已经知道的交友时间的总和;求时间最小。

如果不想看就直接看上面那道题的弱化版，就是求最小值。

这是一道区间dp 区间dp一般是 dp[i][j]表示i到j区间的最优值，第一层循环一般是循环区间长度，第二层就是区间的开头，第三层就是枚举区间的每一个点，递推方程

dp[i][j]当i等于j时，dp[i][j]=0;不等于时 dp[i][j]=min(dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1],dp[i][j])  k大于等于i小于等于j，其中 sum数组为前缀和。

也可以写成这样dp[i][j]=min(dp[i][k]+dp[k+1][j],dp[i][j])+sum[j]-sum[i-1]

这样时间复杂度是

n最大有1000肯定不行的

这是就有了平行四边形不等式优化（我也不知道叫四边形不等式还是....），我也不会证明，直接上结论，在上一些dalao的博客

https://blog.csdn.net/noiau/article/details/72514812

https://www.cnblogs.com/hadilo/p/5800306.html

对于a<b<=c<d 如果有f[a][c]+f[b][d]<=f[b][c]+f[a][d]
可以理解为，交叉小于包含，自己画一个图就懂了，则说这个东西满足四边形不等式

如果递推方程为这种形式dp[i][j]=min(dp[i][k-1],dp[k][j])+w[i][j](i≤k≤j)

介绍一些定义

1、区间包含的单调性：如果对于 a≤b<c≤d，有w[b][c]≤w[a][d]，那么说明f具有区间包含的单调性。就是大区间包含小区间，并且小区间的值不大于大区间的值

2、四边形不等式：对于a<b<=c<d 如果有w[a][c]+w[b][d]<=w[b][c]+w[a][d]
可以理解为，交叉小于包含，自己画一个图就懂了，则说这个东西满足四边形不等式

如果f数组满足区间包含单调性和四边形不等式性质；

就可以用四边形不等式优化

下面给出两个定理：

1、如果上述的w数组满足区间包含单调性和四边形不等式性质，那么数组dp也满足四边形不等式性质。

2.我们再定义s[i][j]表示dp[i][j]取得最优值时对应的K。如果数组dp满足四边形不等式那么s数组单调，即s[i][j-1]<=s[i][j]<=s[i][j+1].

为什么是这个是这个单调等式，我也没看懂，我个人认为是和dp的转移有关。

然后递推方程可以写成如下dp[i][j]=min(dp[i][k-1],dp[k][j])+w[i][j](s[i][j-1]≤k≤s[i+1][j])

dp[i][j]=min(dp[i][k]+dp[k+1][j],dp[i][j])+sum[j]-sum[i-1] (s[i][j-1]≤k≤s[i+1][j])

这样的时间复杂度是

#include<bits/stdc++.h>
using namespace std;
#define cppiofast ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
const int inf=0x3f3f3f3f;
const int N=2010;
int a[N],dp[N][N];
int s[N][N],sum[N];
int main()
{
    cppiofast;
    int n;
    while(cin>>n)
    {
        sum[0]=0;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
            a[i+n]=a[i];
        }
        for(int i=1;i<=2*n;i++)
        {
            sum[i]=sum[i-1]+a[i];
        }
        memset(dp,0x3f,sizeof(dp));
        for(int i=1;i<=2*n;i++)
        {
            dp[i][i]=0;
            s[i][i]=i;
        }
        for(int l=1;l<n;l++)
        {
            for(int i=1;i<2*n-l;i++)
            {
                int j=i+l;
                int cnt=sum[j]-sum[i-1];
                for(int k=s[i][j-1];k<=s[i+1][j];k++)
                {
                    if(dp[i][j]>cnt+dp[i][k]+dp[k+1][j])
                    {
                        dp[i][j]=cnt+dp[i][k]+dp[k+1][j];
                        s[i][j]=k;
                    }
                }
            }
        }
        int ans=inf;
        for(int i=1;i<=n;i++)
        {
            ans=min(ans,dp[i][i+n-1]);
        }
        cout<<ans<<endl;
    }
    return 0;
}