動態規劃(例：01揹包問題)

動態規劃簡介

  動態規劃是運籌學的一個分支，是解決多階段決策過程最優化的一種數學方法，主要用於以時間或低於劃分階段的動態過程最優化。在計算機領域也多有應用，最廣爲人知的應該是動態規劃解01揹包問題。

例題

  給定n個物料的權重和值，將這些物料放在容量爲W的揹包中，以在揹包中獲得最大的總價值。

算法分析

  揹包問題的狀態轉移方程
$f[i,j]=max \left \{ f[i-1,j-w_{i}]+v_{i}(j>=w_{i}),f[i-1,j] \right \}$
  $f[i,j]$表示在前i件物品中選擇若干件放在承重爲 j 的揹包中，可以取得的最大價值。
  $v_{i}$表示第i件物品的價值。
  決策：爲了揹包中物品總價值最大化，第 i件物品應該放入揹包中嗎 ？

算法演繹

  現在假設有有產品$a,b,c,d,e$其價值分別是$5,3,2,5,6$,其重量分別是$3,2,5,8,4$
  使用代碼一次進行演繹，依次計算，只拿第一組，只拿前兩組，…，只拿前五組的情況

#include <iostream>
using namespace std;

int max(int a, int b) { return (a > b) ? a : b; }

int KnapSack(int val[], int wt[], int n, int W)
{
	int ret;
	int ** mat = new int *[n];
	for (int i = 0; i < n; i++) {
		mat[i] = new int[W + 1];
		for (int j = 0; j < W + 1; j++)
			mat[i][j] = 0;
	}
	
		for (int i = 0; i < n; i++) {
			for (int j = 1; j <= W; j++) {
				if (j > wt[i]) {
					if (i == 0)
						mat[i][j] = val[i];
					else
						mat[i][j] = max(val[i] + mat[i - 1][j - wt[i]], mat[i - 1][j]);
				}
				else {
					if (i == 0)
						mat[i][j] = 0;
					else
						mat[i][j] = mat[i-1][j];
				}
		}
	}



	for (int i = 0; i < n; i++) {
		for (int j = 1; j < W + 1; j++) {
			cout << mat[i][j] << ", ";
		}
		cout << endl;
	}
	for (int i = 0; i < n; i++) {
		delete[]	mat[i];
	}
	delete[] mat;

	return 0;
}

int main()
{
	int val[] = { 5,3,2,5,6 };
	int wt[] = { 3,2,5,8,4 };
	int W = 10;
	int n = sizeof(val) / sizeof(val[0]);
	KnapSack(val, wt, n, W);
	system("pause");
	return 0;
}

遞歸算法解題

  遞歸解題是一種很好的思路，只需要藉助簡單的邏輯就能實現這個複雜的功能。

遞歸代碼

#include <iostream>
using namespace std;

int max(int a, int b) { return (a > b) ? a : b; }

int knapSack(int W, int wt[], int val[], int n)
{
	if (n == 0 || W == 0)
		return 0;

	if (wt[n - 1] > W)
		return knapSack(W, wt, val, n - 1);
	else
		return max(
			val[n - 1] + knapSack(W - wt[n - 1],
				wt, val, n - 1),
			knapSack(W, wt, val, n - 1));
}

int main()
{
	int val[] = { 5,3,2,5,6 };
	int wt[] = { 3,2,5,8,4 };
	int W = 50;
	int n = sizeof(val) / sizeof(val[0]);
	cout << knapSack(W, wt, val, n);
	return 0;
}

  上述代碼使用了遞歸的方式實現DP模型.
  其中，

	if (wt[n - 1] > W)
		return knapSack(W, wt, val, n - 1);

  表示，如果當前物品的值大於揹包的總重量，則不取
  其中，

	else
		return max(
			val[n - 1] + knapSack(W - wt[n - 1],
				wt, val, n - 1),
			knapSack(W, wt, val, n - 1));

  表示，如果取當前物品能夠使得價值增加，則取，否則則不取

代碼分析

  這段代碼的精妙之處在於遞歸。遞歸就是自己調用，自己直接遞歸程序與間接遞歸中都要實現當前層調用下一層時的參數傳遞，並取得下一層所返回的結果，並向上一層調用返回當前層的結果。至於各層調用中現場的保存與恢復，均由程序自動實現，不需要人工干預。因此，在遞歸程序的設計中關鍵是找出調用所需要的參數、返回的結果及遞歸調用結束的條件。
  使用遞歸旨在，通過簡單的代碼實現複雜功能。

經典的遞歸程序

//階乘
int factorial(int n)
{
   if(n == 1)
   {
      return 1;
   }
   else
   {
      return n * factorial(n - 1);
   }
}

空間優化後的遞歸代碼

  很多人編寫遞歸求01揹包問題時都採用本文所示第一種寫法，當揹包的個數很大時，則會造成嚴重的內存浪費，這裏對上述代碼進行了空間優化。

#include <iostream>
using namespace std;

int max(int a, int b) { return (a > b) ? a : b; }

int KnapSack(int val[], int wt[], int n, int W)
{
	int ** mat = new int *[2];
	for (int i = 0; i < 2; i++) {
		mat[i] = new int[W + 1];
		for (int j = 0; j < W + 1; j++) {
			mat[i][j] = 0;
		}
	}
	int i = 0;
	while (i < n)
	{
		int j = 0;
		if (i % 2 != 0)
		{
			while (++j <= W)
			{
				if (wt[i] <= j) 
					mat[1][j] = max(val[i] + mat[0][j - wt[i]],
						mat[0][j]);
				else 
					mat[1][j] = mat[0][j];
			}
		}
		else
		{
			while (++j <= W)
			{
				if (wt[i] <= j)
					mat[0][j] = max(val[i] + mat[1][j - wt[i]],
						mat[1][j]);
				else
					mat[0][j] = mat[1][j];
			}
		}
		i++;
	}
	int ret;
	if (0 != n % 2) {
		ret = mat[0][W];
	}
	else {
		ret = mat[1][W];
	}
	for (int i = 0; i < 2; i++) {
		delete []	mat[i];
	}
	delete[] mat;
	return ret;
}

int main()
{
	int val[] = { 5,3,2,5,6 };
	int wt[] = { 3,2,5,8,4};
	int W = 6;
	int n = sizeof(val) / sizeof(val[0]);
	cout << KnapSack(val, wt, n, W) << endl;
	system("pause");
	return 0;
}

作者說

  下期作品將介紹如何使用遞歸的思想解決雙蛋問題,以及詳細介紹動態規劃的數學理論。我的郵箱和支付寶賬號都是[email protected]。期待你的支持和諮詢。