大一剛接觸揹包問題的時候就覺得繞。那時候真的是一點程式碼基礎都沒有強行去理解。每次都是以失敗告終，一直到大二都還不會寫揹包問題。

後來某次模擬賽之後碰到了揹包問題，覺得這個還是挺簡單的，終於是下定決心準備搞一搞這個東西了。

有了一定的基礎理解起來就比以前容易多了。

首先，先分清楚這三個揹包問題。

1.01揹包：有n種物品與承重為m的揹包。每種物品只有一件，每個物品都有對應的重量weight[i]與價值value[i]，求解如何裝包使得價值最大。

2.完全揹包：有n種物品與承重為m的揹包。每種物品有無限多件，每個物品都有對應的重量weight[i]與價值value[i]，求解如何裝包使得價值最大。

3.多重揹包：有n種物品與承重為m的揹包。每種物品有有限件num[i]，每個物品都有對應的重量weight[i]與價值value[i]，求解如何裝包使得價值最大。

啊，說真的大一的我聽了這些已經趴下去睡覺了。

但是真的比對起來會發現，其實這些問題都是很類似的，三種揹包就是三個約束條件不一樣而已。

那麼針對不同的約束條件，開始解決問題。

（一）關於01揹包

吶，為什麼叫它01揹包呢，因為裝進去就是1，不裝進去就是0.所以針對每個物品就兩種狀態，裝，不裝（請允許我用這麼老套的開篇，相信聽過很多次揹包講解的人，大多都是這個開篇的）所以咯，我這個揹包啊，只要有足夠大的空間，這個物品是有可能被裝進去的咯。

所以有狀態轉移方程

dp[i][j] = max( dp[i-1][j] , dp[i-1][ j - weight[i] ] + value[i] )

然後二維陣列的程式碼寫法分分鐘就出來了，反正都是跟前一個狀態去轉移，也沒有什麼寫法上的限制。

#include<bits/stdc++.h>
using namespace std;
int dp[1005][1005];
int weight[1005];
int value[1005];
int main()
{
    int n,m;
    cin>>m>>n;
    memset(dp,0,sizeof(dp));//陣列清空,其實同時就把邊界給做了清理
    for(int i=1; i<=n; i++)
        cin>>weight[i]>>value[i];
    //從1開始有講究的因為涉及到dp[i-1][j],從0開始會越界
    for(int i=1; i<=n; i++)//判斷每個物品能否放進
    {
        for(int j=0; j<=m; j++)//對每個狀態進行判斷
        //這邊兩重for都可以倒著寫，只是需要處理最邊界的情況，滾動陣列不一樣
        {
            if(j>=weight[i])//能放進
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]);

            else dp[i][j]=dp[i-1][j];//不能放進
        }
    }
    cout<<dp[n][m]<<endl;
    return 0;
}
 

然後啊，我們來仔細分析分析就會發現，這個陣列開銷還是很大的，因為是二維的，萬一哪個資料一大，分分鐘記憶體超限，因此有了下邊的解法

傳說中的---------------滾動陣列！！！

啊？什麼是滾動陣列。

說白了二維陣列只是把每個物品都跑一遍，然後到最後一個物品的時候輸出答案，那麼過程值只是計算的時候用一次，我沒必要存下來。所以用一個數組去滾動儲存，然後用後一個狀態的值去覆蓋前面一個狀態。然後形象的叫它：滾動陣列（ma！dan！一點都不形象，我理解了好久）

好吧，假裝很形象。

那麼問題來了，怎麼樣用一維的去代替二維的工作，或者說怎麼去思考。這是一個難點。

那麼我們想，遍歷物品的那個for肯定不能省去，然後裡邊的for也不能省。。。。那麼。就把那個i給他刪了吧，好像確實沒啥用哦。

然後就出現了這樣的程式碼

 for(int i=1; i<=n; i++)
    {
        for(int j=weight[i]; j<=m; j++)
        {
            dp[j]=max(dp[j],dp[j-weight[i]]+value[i]);
        }
    }

看上去好像很厲害的樣子,但是這個絕對是錯的，因為第二個for裡存在某個dp[j]被改動過，然後再次影響到更大的j。就像我們再對一個數組進行移位操作，一不小心就全部成了一樣的數。（別笑，你們以前肯定碰到過|||- -）

額。。回到正題，上邊的程式碼會有重複影響，確實歪打正著的碰上了另一個揹包。這個另說，現在附上正確的思路。

#include<bits/stdc++.h>
using namespace std;
int dp[1005];//滾動陣列的寫法，省下空間省不去時間
int weight[1005];
int value[1005];
int main()
{
    int n,m;
    cin>>m>>n;
    memset(dp,0,sizeof(dp));
    for(int i=1; i<=n; i++)
        cin>>weight[i]>>value[i];
    for(int i=1; i<=n; i++)//對每個數判斷，可反
    {
        for(int j=m; j>=weight[i]; j--)//這裡這個迴圈定死，不能反,反了就是完全揹包
        {
            dp[j]=max(dp[j],dp[j-weight[i]]+value[i]);//其實不斷在判斷最優解，一層一層的
        }
    }
    cout<<dp[m]<<endl;
    return 0;
}

其實就是規定從m開始迴圈，保證了選擇這個物品時，肯定不會重複使用狀態。

（二）關於完全揹包

就像先前講的，完全揹包是每個物品都無限，那麼我只要對著一個性價比最高的物品狂選就是了啊。？？

是嗎？有瑕疵啊！

反例一批一批的啊，認死了選價效比最高的，不一定是完全填滿揹包的啊，萬一最後一個是剛好填滿揹包的，而且價格湊起來剛好比全選價效比最高的物品高的情況比比皆是啊。

啊？什麼，特判最後一個狀態？

你在搞笑嗎|||- -，那我再往前推到倒數第二件，第三件咋辦。總不能對每個物品都特判吧。

所以正解就是動態規劃。狀態轉移方程如下：

dp[i][j] = max ( dp[i-1][j - k*weight[i]] +k*value[i] )     0<=k*weight[i]<=m

這樣看是不是還要多一重for去算k（既放入這個物品的個數）

那麼這裡二維陣列就不如一維的了。

上程式碼：

#include<bits/stdc++.h>
using namespace std;
int dp[100005];//m
struct Node{
    int a,b;
}node[1005];//n

int main(){
    int n;
    while(~scanf("%d",&n)){
        for(int i=0;i<n;i++){
            scanf("%d%d",&node[i].a,&node[i].b);
        }
        int m;
        scanf("%d",&m);
        memset(dp,0,sizeof(dp));
        for(int i=0;i<n;i++){
            for(int j=node[i].b;j<=m;j++){//這樣就是完全揹包
                dp[j]=max(dp[j],dp[j-node[i].b]+node[i].a);
            }
        }
        printf("%d\n",dp[m]);
    }
    return 0;
}

特意換了一種寫法讓整體的程式碼結構看上去更像揹包一點。

其中第二個for中是從小到大遍歷的。這樣就是要利用這種影響（因為物品不知道取幾個呀，能取就減咯，這種影響正好就是這個題目的意思）

（三）關於多重揹包

理解了前面兩種揹包，那麼第三種揹包理解起來就毫不費力了

首先這種可以把物品拆開，把相同的num[i]件物品 看成 價值跟重量相同的num[i]件不同的物品，那麼！！是不是就轉化成了一個規模稍微大一點的01揹包了。對不對！！對不對！！

No BB， show me the code！！

哦， 客官，您要的程式碼：

#include<bits/stdc++.h>
using namespace std;
int dp[1005];
int weight[1005],value[1005],num[1005];
int main()
{
    int n,m;
    cin>>n>>m;
    memset(dp,0,sizeof(dp));
    for(int i=1; i<=n; i++)
        cin>>weight[i]>>value[i]>>num[i];
        
    for(int i=1; i<=n; i++)//每種物品
        
        for(int k=0; k<num[i]; k++)//其實就是把這類物品展開，呼叫num[i]次01揹包程式碼
        
            for(int j=m; j>=weight[i]; j--)//正常的01揹包程式碼
            
                dp[j]=max(dp[j],dp[j-weight[i]]+value[i]);
    
    cout<<dp[m]<<endl;
    return 0;
}

那只是一種理解方法，其實正規的應該是這樣的

dp[i][j] = max ( dp[i-1][j - k*weight[i]] +k*value[i] )     0<=k<=num[i]（這個跟完全揹包差點就一毛一樣了啊喂|||- -）

那麼還是用滾動陣列來寫，而且還又優化了下

程式碼參考：http://blog.csdn.net/acdreamers/article/details/8563283

#include<bits/stdc++.h>
using namespace std;
const int N = 1005;

int dp[N];
int c[N],w[N],num[N];
int n,m;

void ZeroOne_Pack(int cost,int weight,int n)//吧01揹包封裝成函式
{
    for(int i=n; i>=cost; i--)
        dp[i] = max(dp[i],dp[i-cost] + weight);
}

void Complete_Pack(int cost,int weight,int n)//把完全揹包封裝成函式
{
    for(int i=cost; i<=n; i++)
        dp[i] = max(dp[i],dp[i-cost] + weight);
}

int Multi_Pack(int c[],int w[],int num[],int n,int m)//多重揹包
{
    memset(dp,0,sizeof(dp));
    for(int i=1; i<=n; i++)//遍歷每種物品
    {
        if(num[i]*c[i] > m)
            Complete_Pack(c[i],w[i],m);
            //如果全裝進去已經超了重量，相當於這個物品就是無限的
            //因為是取不光的。那麼就用完全揹包去套
        else
        {
            int k = 1;
            //取得光的話，去遍歷每種取法
            //這裡用到是二進位制思想，降低了複雜度
            //為什麼呢，因為他取的1,2,4,8...與餘數個該物品，打包成一個大型的該物品
            //這樣足夠湊出了從0-k個該物品取法
            //把複雜度從k變成了logk
            //如k=11，則有1,2,4,4，足夠湊出0-11個該物品的取法
            while(k < num[i])
            {
                ZeroOne_Pack(k*c[i],k*w[i],m);
                num[i] -= k;
                k <<= 1;
            }
            ZeroOne_Pack(num[i]*c[i],num[i]*w[i],m);
        }
    }
    return dp[m];
}

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        cin>>m>>n;
        for(int i=1; i<=n; i++)
            cin>>c[i]>>w[i]>>num[i];
        cout<<Multi_Pack(c,w,num,n,m)<<endl;
    }
    return 0;
}

幫助個人學習用，如果幫到大家的話也是極好的。