程式碼是前幾周就寫好的, 但是腦子抽了, 導致我再看時不知道是為什麼, 於是乎在CDSN上整理一下..

我是愛C++和演算法的喵線童鞋 //才沒有給自己洗腦 ⁄(⁄ ⁄•⁄ω⁄•⁄ ⁄)⁄

=============================================

首先是最簡單的二維版本

遞迴式:  dp[i][w]=max{dp[i-1][w],dp[i-1][w-wi]+vi}

i表示第i件物品, w表示當前的重量.

這個遞迴式是怎麼來的呢?

基於我們對動態規劃的基本的瞭解, 我們知道: 動態規劃問題一般具有最優子結構性質.

假設某個0/1揹包問題給了n件物品, 總重量不超過Tw,

我們觀察其中一個子問題: 有i件物品, 總重量不超過w

這裡要注意,輸入物品陣列從0下標開始的話, i的迴圈也要對應從0到n-1 (這是一個基礎而又細節的問題=.=)

這裡多說幾句.(畢竟dp是一類問題, 如果能更深入地理解, 有助於以後解決非典型問題. 當然如果已經對"遞迴"有了自己深入而清晰的理解,當然可以跳過啦~~)

思考一個問題: 為什麼會想到"遞迴"?

我自己對遞迴的理解是: 抽象為有限個層次之間的關係(比如第i-1與第i層), 而不必關心整體的實現過程. 如果這個不好理解, 就想一想我們已經熟悉的數學歸納法, 其思想原理是非常類似的. 我們只關心n=k-1到n=k之間是怎麼證明的, 而不會說把每一步都證明出來

.

至於我為什麼一直會這麼糾結為什麼遞迴, 是因為我曾經在青蛙跳臺階上的題目跪了 (手動微笑:::::) 暫時的不成功使人成長, that's quite right.

因此, 我們對於這個子問題dp[i][w], 只需考慮兩種情況: 放第i個物品和不放第i個物品. (即假設前i-1個問題都已經求解, 只關心第i-1層與第i層之間的關係,是不是很像數學歸納法~) =.=其實數歸本身也是一種遞迴恩

如果不放, 這把第i個物品扔掉, 考慮dp[i-1][w];

如果放, 就是dp[i-1][w-wi]+vi; 也就是,把wi的空間騰出來給第i個物品.

比較哪個大就好啦>.<

當然, 為了問題的完備性, 最後我們還要考慮幾種特殊情況:

1)不放物品時, dp[i][w]=0;

2)如果對於子問題的上界w, wi已經超過了w, 那麼就直接不需要考慮這個物品了, 因此此時 dp[i][w]=dp[i-1][w];

3)一般的情況, 就是上面講的dp[i][w]=max{dp[i-1][w],dp[i-1][w-wi]+vi}

因此, 只要寫個雙重迴圈就可以了: for i=0 to n-1 {for j=0 to Tw)

程式碼如下:

#include<iostream>
#include<vector>
using namespace std;
struct KNAP
{
	int w; //weight;
	int v; //value,or portfolio;
};
//二維的方式
void solveKPd(vector<KNAP> cknap, vector<vector<int> > &dp, int n, int Tw)
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j <=Tw; j++)
		{
			if (j<cknap[i].w) dp[i+1][j] = dp[i][j]; 
//j是每一個子問題的w上界,這裡與整體的Tw無關
			else if (dp[i][j] < dp[i][j - cknap[i].w] + cknap[i].v)
				dp[i+1][j] = dp[i][j - cknap[i].w] + cknap[i].v;
			else
				dp[i+1][j] = dp[i][j];
		}
	}
	cout << dp[n][Tw] << endl;
}
int main()
{
	int Tw; int n;
	cin >> Tw >> n;
	vector<KNAP> cknap;
	for (int i = 0; i < n; i++)
	{
		KNAP temp;
		cin >> temp.w >> temp.v;
		cknap.push_back(temp);
	}

	vector< vector<int> > dp(n+1, vector<int>(Tw+1,0));
	solveKPd(cknap, dp, n, Tw);
	system("pause");
	return 0;
}

如果還不理解, 可以把整個dp表格輸出來 (後面我寫了一個輸出程式, 之後會附完整的程式碼)

這是一個例子, n=5, Tw=10, 表頭的w表示每件物品的重量, v表示價值.

================================================

然後是我糾結炸了的

空間優化版本

看上面的輸出資料, 我們會發現其實二維表裡有很多重複的. 這是因為, 從遞迴式的特點來看, 我們只是基於第i-1層對第i層做了更新, 而第i-1層該是什麼樣還是什麼樣.

換言之, 我們只需要知道最後一層的情況, 而不需要儲存之前的結果.

看上面的表格, 其實我們最後輸出的是最右下角的值.

我們這個時候可以得到一個遞迴式

 f[w]=max{f[w], f[w-wi]+vi}

理解起來, 是和上面講的一樣的.
但是, 在具體的實現層面上, 有一個很反直覺的點:

不同於二維dp的雙重迴圈, 空間優化版本的內層迴圈必須是逆序的.

如果這一點理解了, 整個程式的實現就非常容易了.

我們可以對比一下這兩個式子:

dp[i][w]=max{dp[i-1][w],dp[i-1][w-wi]+vi}

 f[w]=max{f[w], f[w-wi]+vi}

可以發現, 在一維遞迴式裡, 要求f[w-wi]+vi 這部分 代替 dp[i-1][w-wi]+vi這部分

我們現在又只有一維陣列. 這就要保證, 在第i次外迴圈時, 呼叫的f[w-wi]實際上是基於第i-1次迴圈得到的值.

而逆序保證了, 對於f[w], 它要呼叫的f[w-wi]一定是第i層迴圈還沒有更新過的, 換言之, f[w-wi]只有可能是第i-1層儲存的資料.

比如說, 我們上面的例子, 內層迴圈從Tw=10開始往下減, 

第一個數就是求f[10]=max{f[10], f[10-wi]+vi} 

這時我們要知道的f[10-wi]其實是二維裡的dp[i-1][10-wi]

那麼我這次迴圈才從10開始, 才第一次啊!! 

根本不會去更新f[10-wi]這個數, 那麼這裡面儲存的是什麼玩意呢?

肯定是第i-1次外迴圈過一遍儲存的結果對不~~

這就是我之前說的"代替"dp[i-1][w-wi]+vi.

假設你這個時候第一個數是求的0, 一直求到了第f[10], 那麼你這個時候再去呼叫f[10-wi].

因為這一下就變成了最後一個數, 那麼排在10前面的數肯定已經被第i層的迴圈動過了

要是還原成二維遞迴式, 就變成了dp[i][w]=max{dp[i][w],dp[i][w-wi]+vi}

這顯然是有問題的.

要是看抽象的解釋還是理解不能, 我們再輸出一下

還是上面的例子 //其中, 0-6表示原來是0,更新為6

//表頭是表示 第i個物品: 重量 價值 e.g 0:2 6

比如我們考慮要放2個物品時, 第一個數是f[10]=max{f[10],f[10-2]+3}

這時候f[10-2]肯定是從上一行來的, 也就是放1個物品時得到的.

而下面假設正序輸出時, 我們會發現放第1個物品時就出了問題.

放到f[5]時, f[5]=max{f[5],f[3]+6}, 這時候第1個物品就被放了兩次.

對應上面的抽象解釋,  f[3]已經被這一層迴圈更新過了, 呼叫的是本層迴圈的值dp[i][w-wi] 

而不是上一層迴圈的值dp[i-1][w-wi]

=============================================

於是, 我們就可以寫出一維部分的核心程式碼啦~

for (int i = 0; i < n; i++)
	{
		for (int j = Tw; j >= cknap[i].w; j--) //逆序
			if (f[j - cknap[i].w] + cknap[i].v > f[j])
				f[j] = f[j - cknap[i].w] + cknap[i].v;
	}
	cout << f[Tw] << endl;

==========================================

如果看到這裡還不明白, 就用下面的cpp多輸出幾組資料試一試

再動筆手動求一求表格中某幾個值, 相信你會懂噠

//畢竟我在智商躺平的狀態下都搞懂了不是嘛=.=

下面這個程式, 有直接輸出表格的過程, 就不用手動完成整個dp表格了.

但是, 揹包問題較大時, 格式可能會很辣眼睛...如果實在有需要可以自己調整

如果只需要結果, 就把巨集定義中的uds 值改為0

如果需要二維揹包求解, 把xy改為1

附上我用的輸入樣例:

10 5
2 6
2 3
6 5
5 4

4 6

==========================================

//author: ECSoBaby, 2018/05/05, Basic Dynamic Programming

#include<iostream>
#include<vector>
using namespace std;

#define uds 1 //如果需要輸出動態規劃的過程幫助理解, 改uds為1; 否則為0
#define xy 0 //xy=1, dp二維陣列; xy=0, dp一位陣列(空間優化)
struct KNAP
{
	int w; //weight;
	int v; //value,or portfolio;
};
//二維的方式
void solveKPd(vector<KNAP> cknap, vector<vector<int> > &dp, int n, int Tw)
{
	for (int i =0; i <n; i++)
	{
		for (int j=0; j <=Tw; j++)
		{
			if (j<cknap[i].w) dp[i+1][j] = dp[i][j]; //j是每一個子問題的w上界,這裡與整體的Tw無關
			else if (dp[i][j] < dp[i][j - cknap[i].w] + cknap[i].v)
				dp[i+1][j] = dp[i][j - cknap[i].w] + cknap[i].v;
			else
				dp[i+1][j] = dp[i][j];
		}
	}
	//cout << dp[n][Tw] << endl;
#if uds
	cout << endl;
	cout << "n: w v\t\t";
	for (int j = 0; j <= Tw; j++)
		cout << j << "\t";
	cout << endl;
	cout << endl;
	for (int i = 0; i <=n; i++)
	{
		if(i==0)  cout << i << ": " <<0<<" "<<0<< "\t\t";
		else
		cout << i << ": "<<cknap[i-1].w<<" "<<cknap[i-1].v<<"\t\t";
		for (int j = 0; j <= Tw; j++)
			cout << dp[i][j] << "\t";
		cout << endl;
	}
	cout << endl;
#else
	cout << dp[n][Tw] << endl;
#endif
	
}

//一維的方式 solveKP refine
void solveKPd_re(vector<KNAP> cknap, vector<int> &f, int n, int Tw)
{
#if uds
	cout <<"\t  ";
	for (int j = Tw; j >= 0; j--)
		cout << j << "\t  ";
	cout << endl << endl;
	for (int i = 0; i < n; i++)
	{
		cout << i <<": "<<cknap[i].w<<" "<<cknap[i].v<< "\t  ";
		for (int j = Tw; j >= cknap[i].w; j--)
		{
			cout << f[j] ;
			if (f[j - cknap[i].w] + cknap[i].v > f[j])
			{
				f[j] = f[j - cknap[i].w] + cknap[i].v;
				cout << "-"<<f[j]<<"\t"; //a-b表示從a變為b
			}
			else cout << "\t";
		}
		cout << endl;
	}
	cout << "\n最終的陣列" << endl;
	cout << "\t  ";
	for (int j = Tw; j >= 0; j--)
		cout << f[j] << "\t  ";
	cout << endl << endl;

	cout << "假設是正序輸出:" << endl;
	for (int i = 0; i <= Tw; i++) f[i] = 0;//初始化
	cout << "\t  ";
	for (int j =0; j <=Tw; j++)
		cout << j << "\t  ";
	cout << endl << endl;
	for (int i = 0; i < n; i++)
	{
		cout << i << ": " << cknap[i].w << " " << cknap[i].v << "\t  ";
		for (int j = 0; j<=Tw; j++)
		{
			cout << f[j];
			if (j > cknap[i].w)
			{
				if (f[j - cknap[i].w] + cknap[i].v > f[j])
				{
					f[j] = f[j - cknap[i].w] + cknap[i].v;
					cout << "-" << f[j] << "\t"; //a-b表示從a變為b
				}
				else cout << "\t";

			}
			else cout << "\t";
		}
		cout << endl;
	}
#else

	for (int i = 0; i < n; i++)
	{
		for (int j = Tw; j >= cknap[i].w; j--) //逆序
			if (f[j - cknap[i].w] + cknap[i].v > f[j])
				f[j] = f[j - cknap[i].w] + cknap[i].v;
	}
	cout << f[Tw] << endl;
#endif
}
int main()
{
	int Tw; int n;
	cin >> Tw >> n;
	vector<KNAP> cknap;
	for (int i = 0; i <n; i++)
	{
		KNAP temp;
		cin >> temp.w >> temp.v;
		cknap.push_back(temp);
	}

#if xy
	vector< vector<int> > dp(n + 1, vector<int>(Tw + 1, 0));
	solveKPd(cknap, dp, n, Tw);
#else 
	vector<int> f(Tw + 1, 0);
	solveKPd_re(cknap, f, n, Tw);
#endif
	system("pause");
	return 0;
}