【洛谷P1880】合并石子

合并石子

Part 1:
链接：https://www.luogu.org/problem/show?pid=1880#sub
数据范围：1 < N <= 100
题解：朴素算法O(n^3)可过
DP[i][j]表示合并i到j的最小(大)代价
每堆石子可以看成先合并成两大堆石子，再把两大堆合并为一堆得到，合并的花费sum[i][j]
动态规划方程

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;
#define is_num(tmp) (tmp<='9'&tmp>='0')
#define maxn 0x3f3f3f3f
int n,sum[250],dp[250][250];
inline int in(void)
{
    char tmp(getchar());
    int res(0),f(1);
    while(!(is_num(tmp)||tmp=='-'))tmp=getchar();
    if(tmp=='-')f=-1,tmp=getchar();
    while(is_num(tmp))
        res=(res<<1)+(res<<3)+(tmp^48),
        tmp=getchar();
    return res*f;
}
inline int DPmin()
{
    for(int i=2;i<=n;i++)
    {
        for(int s=1;s<=2*n-i;s++)
        {
            int e=s+i-1;
            dp[s][e]=maxn;
            for(int k=s;k<e;k++)
            dp[s][e]=min(dp[s][e],dp[s][k]+dp[k+1][e]+sum[e]-sum[s-1]);
        }
    }
    int ans=maxn;
    for(int i=1;i<=n;i++) ans=min(ans,dp[i][i+n-1]);
    return ans; 
}
inline int DPmax()
{
    memset(dp,0,sizeof(dp));
    for(int i=2;i<=n;i++)
    {
        for(int s=1;s<=2*n-i;s++)
        {
            int e=s+i-1;
            dp[s][e]=-maxn;
            for(int k=s;k<e;k++)
            dp[s][e]=max(dp[s][e],dp[s][k]+dp[k+1][e]+sum[e]-sum[s-1]);
        }
    }
    int ans=-maxn;
    for(int i=1;i<=n;i++) ans=max(ans,dp[i][i+n-1]);
    return ans; 
}
int main()
{
    int x;
    n=in();
    for(int i=1;i<=n;i++) x=in(),sum[i]=sum[i+n]=sum[i-1]+x;
    for(int i=1;i<n;i++) sum[i+n]+=sum[n];
    printf("%d\n%d\n",DPmin(),DPmax());
}

Part 2
这里引入四边形不等式优化
凸四边形不等式：w[a][c]+w[b][d]<=w[b][c]+w[a][d]（a <= b < c < = d ）
区间包含关系单调: w[b][c]<=w[a][d]（a <=b < c <= d ）

定理1： 如果w同时满足四边形不等式和决策单调性 ,则f也满足四边形不等式
定理2： 若f满足四边形不等式，则决策s满足 s[i][j-1]<=s[i][j]<=s[i+1][j]
定理3： w为凸当且仅当w[i][j]+w[i+1][j+1]<=w[i+1][j]+w[i][j+1]

证明：http://www.cnblogs.com/Mathics/p/3885745.html 或《动态规划算法的优化技巧》–毛子青
一般利用定理3证明凸函数，然后利用定理2的结论 s[i][j-1]<=s[i][j]<=s[i+1][j]
就能够使得复杂度由O(n^3)降低为O(n^2)

这里可以应用于合并石子中求最小值

#include <cstdio>
#include <cstring>
#define N 1005
int s[N][N],f[N][N],sum[N],n;
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        memset(f,127,sizeof(f));
        sum[0]=0;
        for(int i=1; i<=n; i++){
            scanf("%d",&sum[i]);
            sum[i]+=sum[i-1];
            f[i][i]=0;
            s[i][i+1]=i;
        }
        for(int i=1; i<=n; i++)
            f[i][i+1]=sum[i+1]-sum[i-1];

        for(int i=n-2; i>=1; i--)
            for(int j=i+2; j<=n; j++)
                for(int k=s[i][j-1]; k<=s[i+1][j]; k++)
                if(f[i][j]>f[i][k]+f[k+1][j]+sum[j]-sum[i-1])
                {
                    f[i][j]=f[i][k]+f[k+1][j]+sum[j]-sum[i-1];
                    s[i][j]=k;
                }

        printf("%d\n",f[1][n]);
    }
    return 0;
}

Part 3
1 < N <= 2000 求合并后能得到的最大值
题解：
显然O(n^3)爆了
神奇地 f[i,j]=max(f[i+1][j],f[i][j-1])+w[i][j]
复杂度降到了O(n^2)
链接：http://cogs.pro/cogs/problem/problem.php?pid=1660
//如果有大佬路过，能说说为什么是这样吗，不太理解原理

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define Maxm 999999997
using namespace std;
int f[4010][4010],sum[4010];
int main()
{
    int n; 
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&sum[i]),sum[i]+=sum[i-1];
    for(int i=1;i<=n;i++) sum[i+n]=sum[i]+sum[n];
    int ans=-Maxm;
    for(int i=2;i<=n;i++)
        for(int s=1;s<=2*n-i+1;s++)
        {
            int e=i+s-1;
            f[s][e]=max(f[s+1][e],f[s][e-1]);
            f[s][e]+=sum[e]-sum[s-1];
        }
    for(int i=1;i<=n;i++)
        ans=max(ans,f[i][i+n-1]);
    printf("%d",ans);       
}