0-1背包问题的求解方法及其代码（个人学习用）

测试用例：5 10 2 3 4 4 1 2 5 3 2 4

动态规划代码：

#include <bits/stdc++.h>
#define MAXSIZE 100
using namespace std;

int c, n;
int w[MAXSIZE], v[MAXSIZE], *x;

void Tableout(int table[][MAXSIZE]){
    //输出table表格
    for(int i=n;i>=1;i--){
        cout << "i=" << i << " ";
        for(int j=0;j<=c;j++){
            cout << table[i][j] << " ";
        }
        cout << endl;
    }
}

int* Traceback(int n, int c, int table[][MAXSIZE]){
    //Traceback，对应Knapsack
    int *x = new int[n + 1];
    for(int i=n;i>1;i--){
        //利用递归式判断是否装入物品
        if(table[i][c] == table[i-1][c]){
            x[i] = 0;
        }
        else {
            x[i] = 1;
            c -= w[i]; //更新c，c用作当前容量
        }
    }
    x[1] = (table[n][c])?1:0;
    return x;
}

int* Traceback(int n, int w[], int v[], int p[][2],int *head) {
    //重载Traceback，对应BetterKnapsack
    int *x = new int[n + 1];
    int j = p[head[0] - 1][0], m = p[head[0] - 1][1];
    for (int i = 1; i <= n; i++) {
        x[i] = 0;
        for (int k= head[i+1]; k<=head[i]-1; k++)
        {   //利用跳跃点判断是否装入物品
            if(p[k][0] + w[i] == j && p[k][1] + v[i] == m) {
                x[i] = 1;
                j = p[k][0];
                m = p[k][1];
                break;
            }
        }
    }
    return x;
}

int Knapsack(int n, int c, int w[], int v[]){
    int table[MAXSIZE][MAXSIZE];
    memset(table, 0, sizeof(table));
    for(int i=1;i<=n;i++){
        for(int j=0;j<=c;j++){
            //递归式的代码实现
            if(w[i] <= j){
                table[i][j] = max(table[i - 1][j], table[i-1][j - w[i]] + v[i]);
            }
            else {
                table[i][j] = table[i-1][j];
            }
        }
    }
    Tableout(table);
    x = Traceback(n, c, table);
    return table[n][c];
}

int BetterKnapsack(int n, int c, int w[], int v[]) {
    int p[MAXSIZE][2];
	int *head = new int[n + 2];
	head[n + 1] = 0;
	p[0][0] = 0;
	p[0][1] = 0;
	int left = 0, right = 0, next =1;
	head[n] = 1;
	for (int i = n; i >= 1; i--) {
        //计算跳跃点，利用跳跃点实现递归式
		int k = left;
		for (int j = left; j <= right; j++) {
			if (p[j][0] + w[i] > c) break;
			int y = p[j][0] + w[i], m = p[j][1] + v[i];
			while (k <= right && p[k][0]<y) {
				p[next][0] = p[k][0];
				p[next++][1] = p[k++][1];
			}
			if (k <= right && p[k][0] == y) {
			  if(m<p[k][1]) m= p[k][1];
			   k++;
			}
            if (m > p[next - 1][1]) {
                p[next][0] = y;
                p[next++][1] = m;
            }
            while (k <= right && p[k][1] <= p[next - 1][1]) k++;
        }
        while (k <= right) {
            p[next][0] = p[k][0];
            p[next++][1] = p[k++][1];
        }
        left = right + 1;
        right = next - 1;
        head[i - 1] = next;
    }
    x = Traceback(n, w, v, p, head);
    return p[next - 1][1];
}

int main()
{
    //输入数据
    cin >> n >> c;
    for(int i=1;i<=n;i++){
        cin >> w[i] >> v[i];
    }
    //测试原始算法
    cout << Knapsack(n,c,w,v) << endl;
    for(int i=1;i<=n;i++){
        cout << x[i] << " ";
    }

    //测试改进算法
    cout << endl << "Better:" << endl;
    cout << BetterKnapsack(n, c, w, v) << endl;
    for(int i=1;i<=n;i++){
        cout << x[i] << " ";
    }
    return 0;
}

 回溯法代码：

#include <bits/stdc++.h>
#define MAXSIZE 100
using namespace std;

typedef int typew;
typedef double typev;

struct item{
    //物品定义为结构体类型
    int id;         //物品ID
    typew w;       //物品重量
    typev v, perv; //物品价值，单位重量价值
    item(){}
    item(int i, typew w, typev v){
        //初始化函数
        this->id = i;
        this->w = w;
        this->v = v;
        this->perv = v/w;
    }
};

int n;
bool x[MAXSIZE], bestx[MAXSIZE];
typew c, cw;
typev cv, bestv;
item items[MAXSIZE];

bool cmp_pervalue(item a, item b){
    //重写sort排序函数
    return a.perv > b.perv;
}

typev Bound(int i){
    typew r = c - cw; //剩余容量
    typev b = cv;     //上界
    while(i <= n && items[i].w <= r){
        //装入剩余物品
        r -= items[i].w;
        b += items[i].v;
        i ++;
    }
    if(i <= n)
        //装入一部分物品填满背包
        b += items[i].v * r/items[i].w;
    return b;
}

void Backtrack(int i){
    if(i > n){ //更新最优解
        for(int i=1;i<=n;i++) bestx[i] = x[i];
        bestv = cv;
        return ;
    }
    if(cw + items[i].w <= c){ //左子树
        x[i] = true;
        cw += items[i].w;
        cv += items[i].v;
        Backtrack(i + 1);
        cw -= items[i].w;
        cv -= items[i].v;
    }
    if(Bound(i + 1) > bestv){ //右子树
        x[i] = false;
        Backtrack(i + 1);
    }
}

int main()
{
    //输入数据
    typew tw;
    typev tv;
    cin >> n >> c;
    for(int i=1;i<=n;i++){
        cin >> tw >> tv;
        items[i] = item(i, tw, tv);
    }
    sort(items + 1, items + n + 1, cmp_pervalue);
    for(int i=1;i<=n;i++){
        cout << items[i].id << " " << items[i].w << " " << items[i].v << " " << items[i].perv << endl;
    }
    Backtrack(1);
    cout << bestv << endl;
    for(int i=1;i<=n;i++) if(bestx[i]) cout << items[i].id << " ";
    return 0;
}

分支限界法代码：

#include <bits/stdc++.h>
#define MAXSIZE 100
using namespace std;

typedef int typew;
typedef double typev;

struct item{
    //物品定义为结构体类型
    int id;         //物品ID
    typew w;       //物品重量
    typev v, perv; //物品价值，单位重量价值
    item(){}
    item(int i, typew w, typev v){
        //初始化函数
        this->id = i;
        this->w = w;
        this->v = v;
        this->perv = v/w;
    }
};

struct clue{
    //结构体指针 构造最优解
    clue * parent;
    bool lchild;
};

struct node{
    //活结点表
    typew cw;    //当前重量
    typev b, cv; //上界和当前价值
    int i;       //层数
    clue *p;
    node(){}
    node(int i, typew cw, typev cv, typev b){
        this->i = i;
        this->cw = cw;
        this->cv = cv;
        this->b = b;
    }
    //重载预算符 < 实现优先级
    friend bool operator < (node n1, node n2){ return n1.b < n2.b; }
};

int n;
bool bestx[MAXSIZE];
typew c, cw;
typev cv, bestv;
item items[MAXSIZE];

bool cmp_pervalue(item a, item b){
    //重写sort排序函数
    return a.perv > b.perv;
}

typev Bound(int i){
    typew r = c - cw; //剩余容量
    typev b = cv;     //上界
    while(i <= n && items[i].w <= r){
        //装入剩余物品
        r -= items[i].w;
        b += items[i].v;
        i ++;
    }
    if(i <= n)
        //装入一部分物品填满背包
        b += items[i].v * r/items[i].w;
    return b;
}

typev MaxKnapsack(){
    //初始化
    priority_queue<node> Q; //优先队列
    int i = 1;
    cw = cv = bestv = 0;
    typev b = Bound(1);
    node livenode(1, 0, 0, 0);
    livenode.p = new clue;   //必须为指针分配空间
    livenode.p->parent = NULL;
    //广度优先搜索
    while(i != n + 1){
        typew lcw = cw + items[i].w; //左子树重量
        if(lcw <= c){
            //左子树
            bestv = max(bestv, cv + items[i].v); //更新最优解
            //活结点加入优先队列
            node t = node(i + 1, lcw, cv + items[i].v, b);
            t.p = new clue;
            t.p->parent = livenode.p;
            t.p->lchild = true;
            Q.push(t);
        }
        b = Bound(i + 1);
        if(b >= bestv){ //右子树包含最优解
            //右子树
            node t(i + 1, cw, cv, b);
            t.p = new clue;
            t.p->parent = livenode.p;
            t.p->lchild = false;
            Q.push(t);
        }
        livenode = Q.top(); Q.pop(); //取下一扩展结点
        cw = livenode.cw;
        cv = livenode.cv;
        b = livenode.b;
        i = livenode.i;
    }
    //构造最优解
    for(int j=n;j>0;j--){
        bestx[j] = livenode.p->lchild;
        livenode.p = livenode.p->parent;
    }
    return cv;
}

int main()
{
    //输入数据
    typew tw;
    typev tv;
    cin >> n >> c;
    for(int i=1;i<=n;i++){
        cin >> tw >> tv;
        items[i] = item(i, tw, tv);
    }
    sort(items + 1, items + n + 1, cmp_pervalue);
    for(int i=1;i<=n;i++){
        cout << items[i].id << " " << items[i].w << " " << items[i].v << " " << items[i].perv << endl;
    }
    //计算结果
    MaxKnapsack();
    cout << bestv << endl;
    for(int i=1;i<=n;i++){
        if(bestx[i]) cout << items[i].id << " ";
    }
    return 0;
}