鋼條切割問題求解方法及相關思考

題目來源於《算法導論》第15章第一節。問題如下：

給定一個長度為n英寸的鋼條和一個價格表p_i(i=1,2,3,...n),求能夠使銷售收益r_n最大的切割方案。

問題1：一共有多少種切割方式？

思路一：對於一個長度為n英寸的鋼條，其中一共有n-1個節點可供切割，在每一個節點處都可以選擇切割或者不切割，將對一根鋼條的切割過程視為從第一個節點直到第n-1個節點逐一選擇切割或者不切割的一個過程，利用乘法原理，可以算出來總共有2^n-1種切割方案。以四個節點的鋼條為例：

思路二：也可以將切割一個長度為n英寸的鋼條視作是從n-1個節點當中選擇i（i=0,1,2,....,n-1）個節點進行分割的過程。那么總的分割方式m的計算方式可以使用排列組合的相關知識進行運算。m=C⁰_n-1+C¹_n-1+.....+C^n-1_n-1，根據牛頓二項式公式m=2^n-1。

問題解決方案

一、自頂向下遞歸

從鋼條左邊切割下長度為i的一段（不作任何處理），再對剩下的長度為n-i的鋼條進行切割（遞歸），一個最優的解決方案就是:r_n=max(p_i+r_n-i)(1<=i<=n)，C++代碼實現如下：

#include "stdafx.h"
int CutRod(int p[], int n)//輸入分別為價格數組和問題規模（鋼條大小）
{
    if (n == 0)
    {
        return 0;
    }
    int q = -1000;//保證程序的順利啟動
    for (int i = 1; i <= n; i++)
    {
        if (q < p[i - 1] + CutRod(p, n - i))
        {
            q=p[i - 1] + CutRod(p, n - i);
        }
    }
    return q;
}
int _tmain(int argc, _TCHAR* argv[])
{
    int a[10] = { 1, 5, 8, 9, 10, 17, 17, 20, 24, 25 };//鋼條分割的價格數組
    printf("%d", CutRod(a, 10));
    getchar();
    return 0;
}

 

問題2：這樣的一種遞歸遍歷能否遍歷所有的2^n-1種切割方法？

我之前一直以為這種計算方法無法遍歷到所有的切割方式，以為這種每一次都不考慮左半邊分割的方式會忽略掉某些解。但是細想的話會發現，原來對於左半邊的分割在之前的遍歷當中已經考慮到了，並不需要再考慮。比如，如果從距離鋼條左邊2英寸處分割成兩半然后只考慮右邊的n-2英寸的鋼條的分割的話，不需要考慮將左邊2英寸的鋼條再分為兩個1英寸的情況，因為在計算將左邊分為一個1英寸這種情況的時，另外的n-1部分其中有一種情況就是將其分為一個1寸和n-2寸的情況，這樣就考慮了之前所說的那種情況。也可以對比問題一當中的例子來思考這一問題。

二、利用動態規划的思想解決這一問題

上面所提到的那種算法會在遍歷的過程當中多次計算同樣的子問題，所以需要應用一些策略來減少算法計算數量，下面分別提供了兩種更好的方案。

帶備忘的自頂向下的解決方案：記錄在遍歷的過程當中所遇到的子問題的解，算法在后面的運行當中會對照所記錄的解，如果當前子問題存在解就直接輸出解，否則就執行運算；

自底向上的解決方案：先解決子問題，再利用子問題的解來解決父問題；

1、帶備忘的自頂向下的解決方案C++實現

此程序還可以記錄下每一個子問題的最佳切割方案，最后輸出問題整個問題的最佳切割過程。

#include "stdafx.h"
#include <string>
using namespace std;
struct A{
    int q;
    int* r;
    int* step;
};
//有備忘的自頂向下解決方案
//對規模為n的問題進行計算
int MCutRodA(int a[], int n, int r[],int step[])
{
    int q;//問題的解
    int s;//切割方案
    if (r[n] >= 0)//如果子問題已經有解就返回所記錄的子問題的解
    {
        return r[n];
    }
    if (n == 0)
    {
        q = 0;
        s = 0;
    }
    else{
        q = -100;
        for (int i = 1; i <= n; i++)
        {
            if (q < MCutRodA(a, n - i, r,step) + a[i-1])
            {
                q = MCutRodA(a, n - i, r, step) + a[i - 1];
                s = i;
            }
        }
    }
    r[n] = q;//記錄解
    step[n] = s;//記錄切割方案
    return q;
}
//帶備忘的遞歸解決方案
A MCutRod(int a[],int n)
{
    int* r = (int*)malloc((n + 1)*sizeof(int));//設置一個數組記錄不同規模的子問題的解
    int* step = (int*)malloc((n + 1)*sizeof(int));//設置一個數組記錄不同規模子問題的切割方案
    for (int i = 0; i <= n; i++)
    {
        r[i] = -1;
    }
    A B;
    B.q = MCutRodA(a, n, r, step);
    B.r = r;
    B.step = step;
    return B;
}
int _tmain(int argc, _TCHAR* argv[])
{
    int a[10] = { 1, 5, 8, 9, 10, 17, 17, 20, 24, 25 };//鋼條分割的價格數組
    A B = MCutRod(a, 10);
    printf("不同子問題的最大價值：");
    for (int i = 0; i < 11; i++)
    {
        printf("%d ", B.r[i]);
    }
    printf("\n不同規模子問題從左邊開始的最優切割方式：");
    for (int i = 0; i < 11; i++)
    {
        printf("%d ", B.step[i]);
    }
    printf("\n");
    printf("%d", B.q);
    int n = 10;
    printf("最佳的切割方式為：");
    while (n > 0)
    {
        printf("%d ", B.step[n]);
        n = n - B.step[n];
    }
    getchar();
    return 0;
}

 

2、自底向上解決方案的C++實現

int BTUCutRod(int a[], int n)
{
    int* r = (int*)malloc((n + 1)*sizeof(int));
    r[0] = 0;
    for (int i = 1; i <= n; i++)//遍歷所有可能的問題規模數
    {
        int q = -100;
        for (int j = 1; j <= i; j++)
        {
            if ((a[j - 1] + r[i - j]) > q)
            {
                q = a[j - 1] + r[i - j];
            }
        }
        r[i] = q;
    }
    return r[n];
}
int _tmain(int argc, _TCHAR* argv[])
{
    int a[10] = { 1, 5, 8, 9, 10, 17, 17, 20, 24, 25 };//鋼條分割的價格數組
    printf("%d", BTUCutRod(a, 10));
    getchar();
    return 0;
}