Cutting Sticks-uva10003 紫书P278 动态规划+四边形不等式优化

vjudge题目链接
个人认为动态规划的难点有两个：什么时候能用动态规划？状态转移方程怎么写？

首先要明确为什么是用动态规划解这道题？

分析这道题：当我们把木棒从某点切割时，还要继续切割剩下的两段木棒。我们当然希望剩下的两段木棒在切割时花费是最少的，那么在继续切割的时候我们仍然希望新切割出来的木棒是花费最少的，那么在切割大段木棒的时候会用到小段木棒的切割结果，也就是说我们需要先确定小段木棒的最佳结果来推出大段木棒的最佳结果，这里就用到了动规的思想。

解决了能不能用动规的问题后就是怎么写状态转移方程？

如图，将左右端点人为地定义为切割点0和n+1（这里以n=4为例），输入的切割点从1开始，我们用dp[i][j]来保存切割点i~j段的花费。同时还要用数组a[]来保存切割点的位置。
既然根据小段木棒的切割结果来确定大段木棒的切割点，那么我们先确定小段木棒的最佳结果（一般的动规也是从小的部分开始）。
如果j-i<=1，那么这段木棒不能再被切割，将其值设置为0。
如果j-i>=2，那么这段木棒还能被继续切割，我们需要选取一个切割点k（i<k<j），那么在切割点位于k时的最佳结果为dp[i][k]+dp[k][j]+a[j]-a[i]，只要将k从i+1遍历到j-1，然后选取最小的结果即可。
因此状态转移方程确定为：

dp[i][j]=min(dp[i][k]+dp[k][j] | i<k<j ) + a[j] - a[i]

以下是AC代码：

#include <bits/stdc++.h>
#define mem(a) memset(a, 0, sizeof(a))
#define inf 0x3f3f3f3f
using namespace std;

int main()
{
    int a[55];      //保存切割点位置(切割点下标从1开始)
    int dp[55][55]; //dp[i][j]表示切割i~j段的木头所需的最小花费
    int l, n;
    a[0] = 0;
    while (cin >> l && l)
    {
        cin >> n;
        a[n + 1] = l;
        for (int i = 1; i <= n; i++)
        {
            cin >> a[i];
        }
        mem(dp);
        for (int i = 2; i <= n + 1; i++)
        {
            for (int j = 0; j <= n + 1 - i; j++)
            {
                dp[j][j + i] = inf;
                for (int k = j + 1; k < j + i; k++) //选择分割点
                {
                    dp[j][j + i] = min(dp[j][k] + dp[k][j + i], dp[j][j + i]);
                }
                dp[j][j + i] += a[j + i] - a[j];
            }
        }
        cout << "The minimum cutting is " << dp[0][n + 1] << "."
             << "\n";
    }
    return 0;
}

虽然这道题是解决了，但是AC代码的复杂度达到了O(n^3)级别，如果这题的数据量比较大，很可能就会超时了，所以下面要介绍一种优化动规的方法：四边形不等式

在这里推荐一位博主对四边形不等式介绍的文章 文章链接
从这位博主的文章中截取了四边形不等式定理，如果看不懂证明可以直接用定理优化dp

用了四边形不等式优化后的代码：

#include <bits/stdc++.h>
#define mem(a) memset(a, 0, sizeof(a))
#define inf 0x3f3f3f3f
using namespace std;

int main()
{
    int a[55];      //保存切割点位置(切割点下标从1开始)
    int dp[55][55]; //dp[i][j]表示切割i~j段的木头所需的最小花费
    int s[55][55];  //s[i][j]表示dp[i][j]的最佳k值
    int l, n;
    for (int i = 0; i < 55; i++) //初始化s
    {
        s[i][i + 1] = i;
    }
    a[0] = 0;
    while (cin >> l && l)
    {
        cin >> n;
        a[n + 1] = l;
        for (int i = 1; i <= n; i++)
        {
            cin >> a[i];
        }
        mem(dp);
        for (int i = 2; i <= n + 1; i++)
        {
            for (int j = 0; j <= n + 1 - i; j++)
            {
                dp[j][j + i] = inf;
                //s[i][j-1] <= s[i][j] <= s[i+1][j] 即 s[i][j-1] <= k <= s[i+1][j]
                for (int k = s[j][j + i - 1]; k <= s[j + 1][j + i]; k++) //选择分割点
                {
                    if (dp[j][k] + dp[k][j + i] < dp[j][j + i])
                    {
                        dp[j][j + i] = dp[j][k] + dp[k][j + i];
                        s[j][j + i] = k;
                    }
                }
                dp[j][j + i] += a[j + i] - a[j];
            }
        }
        cout << "The minimum cutting is " << dp[0][n + 1] << "."
             << "\n";
    }
    return 0;
}