01背包学习

其他解析
1.01背包问题
有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 i 件物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。
接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
8

方法：从大到小枚举体积

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

int dp[maxn];
int n, m;

int main () {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        int w, v;
        cin >> w >> v;
        for (int j = m; j >= w; j--) {
            dp[j] = max(dp[j], dp[j - w] + v);
        }
    }
    cout << dp[m];
    return 0;
}

2.完全背包问题
有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 i 件物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。
接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
8
方法从小到大枚举体积

#include<iostream>
using namespace std;
const int maxn= 1001;
int dp[maxn];
int w[maxn], v1[maxn];
int main () {
    int n, v;
    cin >> n >> v;
    for (int i = 1; i <= n; i++) {
        cin >> w[i] >> v1[i];
    }
    for (int i = 1; i <= n; i++) {
        for (int j = w[i]; j <= v; j++) {
            dp[j] = max(dp[j], dp[j - w[i]] + v1[i]);
        }
    }
    cout << dp[v];
    return 0;
}

3.多重背包问题
有 N 种物品和一个容量是 V 的背包。
第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。
接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N≤1000
0<V≤2000
0<vi,wi,si≤2000
提示：
本题考查多重背包的二进制优化方法。
输入样例
4 5
1 2 3
2 4 1
3 4 3
4 5 2
输出样例：
10
根据数量，利用1 2 4 8。。。 拆分成01背包问题

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

int dp[maxn];
int n, m;
struct node {
    int w, v;
};
int main () {
    cin >> n >> m;
    vector<node> cp;
    for (int i = 1; i <= n; i++) {
        int w, v, s;
        cin >> w >> v >> s;
        for (int k = 1; k <= s; k *= 2) {
            s -= k;
            cp.push_back({w * k, v * k});
        }
        if (s > 0)
            cp.push_back({w * s, v * s});
    }
    vector<node>::iterator it = cp.begin();
    for (; it != cp.end(); it++) {
        for (int j = m; j >= it->w; j--) {
            dp[j] = max(dp[j], dp[j - it->w] + it->v);
        }
    }
    cout << dp[m];
    return 0;
}

4.混合背包问题
有 N 种物品和一个容量是 V 的背包。
物品一共有三类：
第一类物品只能用1次（01背包）；
第二类物品可以用无限次（完全背包）；
第三类物品最多只能用 si 次（多重背包）；
每种体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。
接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。
si=−1 表示第 i 种物品只能用1次；
si=0 表示第 i 种物品可以用无限次；
si>0 表示第 i 种物品可以使用 si 次；
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
−1≤si≤1000
输入样例
4 5
1 2 -1
2 4 1
3 4 0
4 5 2
输出样例：
8

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1001;
int n, v;
int dp[maxn];
struct node {
    int kind;
    int w, v;
};
int main () {
    cin >> n >> v;
    vector<node> cp;
    for (int i = 1; i <= n; i++) {
        int w, v, s;
        cin >> w >> v >> s;
        if (s < 0) cp.push_back({-1, w, v});
        else if (s == 0) cp.push_back({0, w, v});
        else {
            for (int k = 1; k <= s; k *= 2) {
                s -= k;
                cp.push_back({-1, w * k, v * k});
            }
            if (s > 0) cp.push_back({-1, w * s, v * s});
        }
    }
    for (vector<node>::iterator it = cp.begin(); it != cp.end(); it++) {
        if (it->kind < 0) {
            for (int j = v; j >= it->w; j--) {
                dp[j] = max(dp[j], dp[j - it->w] + it->v);
            }
        } else {
            for (int j = it->w; j <= v; j++) {
                dp[j] = max(dp[j], dp[j - it->w] + it->v);
            }
        }
    }
    cout << dp[v];
    return 0;
}

5.二维费用的背包问题
有 N 件物品和一个容量是 V 的背包，背包能承受的最大重量是 M。

每件物品只能用一次。体积是 vi，重量是 mi，价值是 wi。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，总重量不超过背包可承受的最大重量，且价值总和最大。
输出最大价值。

输入格式
第一行两个整数，N，V,M，用空格隔开，分别表示物品件数、背包容积和背包可承受的最大重量。

接下来有 N 行，每行三个整数 vi,mi,wi，用空格隔开，分别表示第 i 件物品的体积、重量和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N≤1000
0<V,M≤100
0<vi,mi≤100
0<wi≤1000
输入样例
4 5 6
1 2 3
2 4 4
3 4 5
4 5 6
输出样例：
8
将背包的体积和重量构造成一个二维的数组，这题是一个01背包，所以从大到小枚举体积。

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

int dp[101][101];
int n, m, v;

int main () {
    cin >> n >> v >> m; // 
    for(int i = 1; i <= n; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        for (int j = v; j >= a; j--) {
            for (int z = m; z >= b; z--) {
                dp[j][z] = max(dp[j][z], dp[j - a][z - b] + c);
            }
        }
    }
    cout << dp[v][m];
    return 0;
}

6.分组 背包问题
有 N 组物品和一个容量是 V 的背包。
每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 vij，价值是 wij，其中 i 是组号，j 是组内编号。
求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。
接下来有 N 组数据：
每组数据第一行有一个整数 Si，表示第 i 个物品组的物品数量；
每组数据接下来有 Si 行，每行有两个整数 vij,wij，用空格隔开，分别表示第 i 个物品组的第 j 个物品的体积和价值；
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤100
0<Si≤100
0<vij,wij≤100
输入样例
3 5
2
1 2
2 4
1
3 4
1
4 5
输出样例：
8
在01背包的基础上，进行决策，选每一组的第i个，求max

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

const int maxn = 101;

int dp[maxn], v1[maxn], w[maxn];

int n, v;
int  main () {
    cin >> n >> v;
    for (int i = 1; i <= n; i++) {
        int t;
        cin >> t;
        for (int j = 1; j <= t; j++)    cin >> v1[j] >> w[j];
        for (int j = v; j >= 0;j--) {
            for (int k = 1; k <= t; k++) {
                if (j >= v1[k])
                    dp[j] = max(dp[j], dp[j - v1[k]] + w[k]);
            }
        }
    }
    cout << dp[v];
    return 0;
}

9.有依赖的背包问题
有 N 个物品和一个容量是 V 的背包。
物品之间具有依赖关系，且依赖关系组成一棵树的形状。如果选择一个物品，则必须选择它的父节点。
如果选择物品5，则必须选择物品1和2。这是因为2是5的父节点，1是2的父节点。
每件物品的编号是 i，体积是 vi，价值是 wi，依赖的父节点编号是 pi。物品的下标范围是 1…N。
求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行有两个整数 N，V，用空格隔开，分别表示物品个数和背包容量。
接下来有 N 行数据，每行数据表示一个物品。
第 i 行有三个整数 vi,wi,pi，用空格隔开，分别表示物品的体积、价值和依赖的物品编号。
如果 pi=−1，表示根节点。 数据保证所有物品构成一棵树。
输出格式
输出一个整数，表示最大价值。
数据范围
1≤N,V≤100
1≤vi,wi≤100
父节点编号范围：
内部结点：1≤pi≤N;
根节点 pi=−1;
输入样例
5 7
2 3 -1
2 2 1
3 5 1
4 7 2
3 6 2
输出样例：
11
树形dp+分组背包

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 110;

int n, m;
int h[N], e[N], ne[N], idx;
int v[N], w[N];
int f[N][N];

void add(int x, int y) {
    e[idx] = y, ne[idx] = h[x], h[x] = idx++;
}

void dfs(int x) {
    for (int i = h[x]; i != -1; i = ne[i]) {
        int y = e[i];
        dfs(y);
        for (int j = m - v[x]; j >= 0; j--) {
            for (int k = 0; k <= j; k++) {
                f[x][j] = max(f[x][j], f[x][j - k] + f[y][k]);
            }
        }
    }
    for (int i = m; i >= v[x]; i--) {
        f[x][i] = f[x][i - v[x]] + w[x];
    }
    for (int i = 0; i < v[x]; i++) {
        f[x][i] = 0;
    }
}

int main() {
    memset(h, -1, sizeof h);
    cin >> n >> m;
    int root;
    for (int i = 1; i <= n; i++) {
        int p;
        cin >> v[i] >> w[i] >> p;
        if (p == -1) {
            root = i;
        } else {
            add(p, i);
        }
    }
    dfs(root);
    cout << f[root][m] << endl;
    return 0;
}

01背包问题（无优化）：

for(i=1;i<=n;i++)
     for(j=cost[i];j<=V;j++){
        dp[i][j]=max(dp[i-1][j-cost[i]]+val[i],dp[i-1][j]); 
             //当前物品，放还是不放 
         }

01背包问题（1维优化）：

dp[j]表示体积为j的时候的最大价值
 for(i=1;i<=n;i++)
     for(j=V;j>=cost[i];j--)
         dp[j]=max(dp[j],dp[j-cost[i]]+val[i]);

完全背包：

for (int i = 1; i <= 5; i++)
        for (int j = w[i]; j <= 10;j++)
                dp[j] = max(dp[j],dp[j - w[i]] + v[i]);

多重背包问题：

for(int i=1; i<=n; i++) {
	if(w[i]*a[i]>m)     {
		for(int c=0; c<=m; c++)         {
			if(c>=w[i]) f[c]=max(f[c],f[c-w[i]]+v[i]);
		}
	}     else     {
		k=1;
		amount=a[i];
		while(k<amount)          {
			for(int c=k*w[i]; c>=0; c--)              {
				if(c>=w[i])   f[c]=max(f[c],f[c-w[i]]+k*v[i]);
			}
			amount-=k;
			k<<=1;
		}
		for(int c=amount*w[i]; c>=0; c--)          {
			f[c]=max(f[c],f[c-w[i]]+amount*v[i]);
		}
	}
}