背包问题

背包问题：

• 已知有n种物品，一个可容纳M重量的背包，物品i（1<=i<=n）的重量$w_i$，对应的价值为$p_i$。怎样的装包，才能使包中物品的总价值最大？

• 已知条件：n，M，（$p_1$,$p_2$,…,$p_n$），（$w_1$,$w_2$,…,$w_n$）。

背包问题分为2种：如果物品可以拆分，就是普通背包问题。如果每个物品不能拆分，就是01背包问题。

普通背包问题－贪心算法

由于普通背包问题，物品可以拆分，假设物品i装进背包的部分的x[i]，其中0<=$x_i$<=1。思想为：1.按效益值$p_i$/$w_i$比值的降序排列；2.按排序次序将物品放入背包，如果剩余容量能放下物品w[i]，则$x_i$＝1，能放下部分，则$x_i$=leftM/$w_i$，否则$x_i$=0。
最终$\sum_1^n w_ix_i =M$，$\sum_1^n p_ix_i 即为最大收益$。

例如：n=3,M=20,($p_1$,$p_2$,$p_3$)=(25,24,15),($w_1$,$w_2$,$w_3$)=(18,15,10)。

解：按$p_i$/$w_i$排序，物品排序为（物品2，物品3，物品1），装包过程$x_2$=1，$x_3$=1／2，$x_2$=0。结果($x_1$,$x_2$,$x_3$)=(0,1,1/2),最大效益值为31.5。

01背包问题－动态规划

对于0／1背包问题，可以通过作出变量$(x_1,x_2,...,x_i)$的一个决策序列$f_i(x)$来得到它的解。而对于变量x的决策就是决定它取0还是1。

如果设$f_j(x)$是KNAP(1,j,x)最优值的解，那么，$f_n(M)$就可以表示为

$$f_n(M)＝max\{f_{n-1}(M)，f_{n-1}(M-w_n)+p_n\}$$
对于任意的$f_i(x)$，这里i>0,则有
$$f_i(x)＝max\{f_{i-1}(x)，f_{i-1}(x-w_i)+p_i\}$$
为了能尤前向后递推最后求解$f_n(M)$，需从$f_0(x)$开始。对于x>=0，$f_0(x)$=0，当x<0，$f_0(x)$=-$\infty$。

其实，如果画图，可以看出每个$f_i$都是由一些序偶($p_j$,$w_j$)组成的集合所说明，其中$w_j$是使$f_i$在某处产生一次阶跃的x值，$p_j=f_i(w_j)$。第一对序偶是$(p_0,w_0)$。

算法思想：

• 设$S_0$＝{ (0,0) }。
• $S^{i-1}$是$f_{i-1}$的所有序偶的集合，$S_1^i$是$f_{i-1}(x-w_i)+p_i$的所有序偶的集合。求$S_1^i$，就是把序偶$(p_i,w_i)$加到$S^{i-1}$中每一对序偶，
  $$S_1^i={(p,w)|(p-p_i,w-w_i) \in S^{i-1}}$$
• 上面第二个公式中取max值，其实就是将$S^{i-1}$和$S^{i-1}$归并得到$S^i$。归并过程中，如果$S^{i-1}$和$S^{i-1}$之一有序偶($p_j$,$w_j$)，另一个序偶($p_k$,$w_k$)，并且在$w_j>=w_k$的同时有$p_j<=p_k$，那么序偶($p_j$,$w_j$)被舍弃。

算法时间复杂度为O(n)，空间复杂度为O(n)。

例如:n=3,M=6,($p_1$,$p_2$,$p_3$)=(1,2,5),($w_1$,$w_2$,$w_3$)=(2,3,4)。

解：
$S^0=\{(0,0)\}$
- $S_1^1=\{(1,2)\}$
$S^1=\{(0,0),(1,2)\}$
- $S_1^2=\{(2,3),(3,5)\}$
$S^2=\{(0,0),(1,2),(2,3),(3,5)\}$
- $S_1^3=\{(5,4),(6,6),(7,7),(8,9)\}$
$S^3=\{(0,0),(1,2),(2,3),(3,5),(6,6),(7,7),(8,9)\}$
根据支配规则，在$S^3$中删去了序偶(3,5)。

可知，f(6)=6。

01背包问题代码

//保存成KNAP.h头文件
//然后在项目主函数，main中KNAP::Test::main();调用即可
#include <iostream>
#include <vector>

using namespace std;

namespace KNAP{
    struct PWPoint{
        int p;
        int w;
        PWPoint(int _p,int _w):p(_p),w(_w){ }
    };

    class Solution{
    public:
        int knap(int n,int M,vector<int> p,vector<int> w){
            vector<PWPoint > fn,fn1;
            fn.push_back(PWPoint(0,0));
            int j,k;
            for(int i=0;i<n;i++){
                //get s1(i)
                fn1.clear();
                for(j=0;j<fn.size();j++){
                    fn1.push_back(PWPoint(fn[j].p+p[i],fn[j].w+w[i]));
                }

                //raw merger s(i-1) and s1(i) to s(i)
                j=0,k=0;
                while(j<fn.size() && k<fn1.size()){
                    if(fn[j].w>fn1[k].w){
                        fn.insert(fn.begin()+j,fn1[k]);
                        j++;
                        k++;
                    }else{
                        j++;
                    }
                }
                while(k<fn1.size()){
                    fn.push_back(fn1[k++]);
                }

                //delete except in s(i)
                j=0;
                while(j<fn.size()){
                    if(j<fn.size()-1){
                        if(fn[j].w == fn[j+1].w){
                            if(fn[j].p>=fn[j+1].p){
                                fn.erase(fn.begin()+j+1);
                            }else{
                                fn.erase(fn.begin()+j);
                            }
                        }else{
                            if(fn[j].p>=fn[j+1].p){
                                fn.erase(fn.begin()+j+1);
                            }else{
                                j++;
                            }
                        }
                    }else{
                        j++;
                    }
                }

                //delete fn[i] if fn[i].w>M
            }

            //get map_p for M
            int cur_p=fn[0].p;
            for(int i=1;i<fn.size();i++){
                if(M<fn[i].w){
                    break;
                }else{
                    cur_p=fn[i].p;
                }
            }

            return cur_p;

        }
    };

    class Test{
    public:
        static void main(){
            int n=3,M=6;
            vector<int> p{1,2,5},w{2,3,4};
            Solution s;
            int ret = s.knap(n, M, p, w);
            cout<< ret <<endl;
        }
    };
}