四边形不等式算法证明

ps:本人小白，文章可能存在错误，希望大佬谅解或指出错误

先来看一道常规的区间dp，在这里以石子合并为例题

题目描述：

有N堆石子排成一排，每堆石子有一定的数量。现要将N堆石子并成为一堆。合并的过程只能每次将相邻的两堆石子堆成一堆，每次合并花费的代价为这两堆石子的和，经过N-1次合并后成为一堆。求出总的代价最小值。

输入

有多组测试数据，输入到文件结束。
每组测试数据第一行有一个整数n，表示有n堆石子。
接下来的一行有n（0< n <200）个数，分别表示这n堆石子的数目，用空格隔开

输出

输出总代价的最小值，占单独的一行

样例输入

3
1 2 3
7
13 7 8 16 21 4 18

样例输出

9
239

先来个朴素版本的：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 205;
int n, x;
int sum[maxn];
int dp[maxn][maxn];
int main()
{
    while(~scanf("%d",&n))
    {
        sum[0] = 0;
        memset(dp, 0x3f, sizeof(dp));
        for(int i = 1;i <= n;i ++)
        {
            scanf("%d", &x);
            sum[i] = sum[i - 1] + x;
            dp[i][i] = 0;
        }
        for(int len = 2;len <= n;len ++)
        for(int i = 1;i <= n;i ++)
        {
            int j = i + len - 1;
            if(j > n) continue;
            for(int k = i;k < j;k ++)
            {
                dp[i][j] = min(dp[i][j], dp[i][k]+dp[k+1][j] + sum[j] - sum[i-1]);
            }
        }
        printf("%d\n", dp[1][n]);
    }
    return 0;
}

其中的区间dp算法不必说，是O(n^3)的。那么能不能优化呢，肯定是可以的，这就是要说的四边形不等式优化。社s[i, j]是 i 到 j 的最佳分割点，由四边形不等式我们可以得知第三重循环寻找最佳分割点的范围就可以从(i, j)压缩到(s[i, j - 1], s[i + 1, j])，这样就可以优化到O(n^2)。代码如下：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 205;
int n,x;
int sum[maxn];
int dp[maxn][maxn];
int s[maxn][maxn];
int main()
{
    while(~scanf("%d",&n))
    {
        sum[0] = 0;
        memset(dp, 0x3f, sizeof(dp));
        for(int i = 1;i <= n;i ++)
        {
            scanf("%d",&x);
            sum[i] = sum[i-1] + x;
            dp[i][i] = 0;
            s[i][i] = i;
        }
        for(int len = 2;len <= n;len ++)
        for(int i = 1;i <= n;i ++)
        {
            int j = i + len - 1;
            if(j > n) continue;
            for(int k = s[i][j-1];k <= s[i+1][j];k ++)
            {
                if(dp[i][k] + dp[k + 1][j] + sum[j] - sum[i-1] < dp[i][j])
                {
                    dp[i][j] = dp[i][k] + dp[k + 1][j] + sum[j] - sum[i - 1];
                    s[i][j] = k;
                }
            }
        }
        printf("%d\n",dp[1][n]);
    }
    return 0;
}

我们先来了解一下四边形不等式

设m[i,j]表示动态规划的状态量（就是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]满足四边形不等式。

这是使用四边形不等式优化的前题，只有先证明它满足这个条件才可以使用（一般用数学归纳法证明）

四边形不等式的证明(这里以求min为例)：

证明 s[i, j - 1] ≤ s[i, j] ≤ s[i + 1, j]

设 d = s[i, j]         i + 1 ≤ k < d       (d代表 i 到 j 的最优分割点)

显然   

         

    且                 (m[i, j] 在 d 取到最小值)

构造一个原式：

           

       =  

       =   

       =   

∵ m 满足四边形不等式

∴ 对于 i < i + 1 ≤ k < d     则有：

              

带入原式可得

               

 ∵           

 ∴            

∴             

设             b = s[i + 1, j]                  (b 是i + 1 到 j 上的最优分割点)

则有                

              (ps: 意思就是说在[i + 1, j] 上存在 b 使得 m[i + 1, j] 最小，很明显 不是最小的，而 i + 1 ≤ k < d ，也就是说 b 肯定不在[i + 1, d) 所以 b ≥ d)

 ∴           s[i, j] ≤ s[i + 1, j]      同理可得  s[i, j - 1] ≤ s[i, j]

所以第三重循环的范围就可以从(i, j) 压缩到 (s[i, j - 1], s[i + 1, j])

如果讲的有不当之处请多多指出~~转载请注明原地址