背包dp九题

news2024/9/20 22:51:09

文章目录

  • 01背包
    • 代码
  • 完全背包
    • 代码
  • 多重背包
    • 代码
  • 混合背包
    • 代码
  • 二维费用的背包问题
    • 代码
  • 分组背包问题
    • 代码
  • 有依赖的背包问题
    • 代码
  • 背包问题求方案数
    • 代码
  • 背包问题求具体方案
    • 代码

01背包

N N N 件物品和一个容量是 V V V 的背包。每件物品只能使用一次。
i i i 件物品的体积是 v i v_i vi,价值是 w i w_i wi
求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。
输出最大价值。
输入格式
第一行两个整数, N , V N,V NV,用空格隔开,分别表示物品数量和背包容积。
接下来有 N N N 行,每行两个整数 v i , w i v_i, w_i vi,wi,用空格隔开,分别表示第 i i i 件物品的体积和价值。

输出格式
输出一个整数,表示最大价值。
数据范围
0 < N , V ≤ 1000 0 \lt N, V \le 1000 0<N,V1000
0 < v i , w i ≤ 1000 0\lt v_i, w_i \le 1000 0<vi,wi1000

输入样例

4 5
1 2
2 4
3 4
4 5

输出样例

8

代码

  // 暴力 朴素 法
#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int f[N][N]; // 二维的f[i][j],前 i 个物品,体积不超过 j 的最大值
int v[N],w[N]; // 储存 体积 和 价值
int n,m;
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)   cin>>v[i]>>w[i];
    for(int i=1;i<=n;i++)
    {    // 利用上次的更新的 f 数组
        for(int j=0;j<=m;j++)
        {
            f[i][j]=f[i-1][j]; // 不选第 i 个物品,体积不超过 j 的最优解
             // 满足选择第 i 个物品,体积不超过 j-v[i] 的最优解
            if(j>=v[i]) f[i][j]=max(f[i][j],f[i-1][j-v[i]]+w[i]);
        }
    }
    cout<<f[n][m];
    return 0;
}
  // 优化一次,由上述的暴力 朴素 法,可知转化成为一维数组对最后的结果无影响
#include<bits/stdc++.h>
using namespace std;
int f[1010];
int v[1010],w[1010];
int main()
{
    int n,s;cin>>n>>s;
    for(int i=1;i<=n;i++)cin>>v[i]>>w[i];
    for(int i=1;i<=n;i++)
    {	// 利用上次的更新的 f 数组
        for(int j=s;j>=0;j--)
        {	 // 满足选择第 i 个物品,体积不超过 j-v[i] 的最优解
            if(j>=v[i]) f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[s];
    return 0;
}
  // 终极版本  时间复杂度:Θ(V∗N)  空间复杂度:Θ(V)
#include<bits/stdc++.h>
using namespace std;
int f[1010],v[1010],w[1010]; // 状态转移方程变为 一维 ,优化利用上次的 f[i]
int main()
{
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++)   cin>>v[i]>>w[i];
    for(int i=1;i<=n;i++)
    {	 // 从大到小枚举,利用上一层次的f[i](完全背包为从小到大,利用本层次的f[i])
    	 // 由上述优化一次得,枚举到 v[i] 即可
        for(int j=m;j>=v[i];j--)
        {
            f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m];
    return 0;
}

完全背包

N N N 种物品和一个容量是 V V V 的背包,每种物品都有无限件可用。
i i i 种物品的体积是 v i v_i vi,价值是 w i w_i wi
求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。
输出最大价值。
输入格式
第一行两个整数, N , V N,V NV,用空格隔开,分别表示物品种数和背包容积。
接下来有 N N N 行,每行两个整数 v i , w i v_i, w_i vi,wi,用空格隔开,分别表示第 i i i 种物品的体积和价值。
输出格式
输出一个整数,表示最大价值。
数据范围
0 < N , V ≤ 1000 0 \lt N, V \le 1000 0<N,V1000
0 < v i , w i ≤ 1000 0 \lt v_i, w_i \le 1000 0<vi,wi1000
输入样例

4 5
1 2
2 4
3 4
4 5

输出样例

10

代码

  // 朴素法
#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int f[N][N]; // 二维的f[i][j],前 i 个物品,体积不超过 j 的最大值
int v[N],w[N];
int n,m;
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)   cin>>v[i]>>w[i];
    for(int i=1;i<=n;i++)
    {	// 利用到 本次和上次 的更新的 f 数组
        for(int j=0;j<=m;j++)
        {
            f[i][j]=f[i-1][j]; // 不选第 i 个物品,体积不超过 j 的最优解
            if(j>=v[i]) // 选第 i 个物品,体积不超过 j 的最优解
                f[i][j]=max(f[i][j],f[i][j-v[i]]+w[i]);
        }
    }
    cout<<f[n][m];
    return 0;
}
  // 一次优化,由朴素法得转化成 一维数组 对结果无影响
#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int f[N];
int v[N],w[N];
int n,m;
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)   cin>>v[i]>>w[i];
    for(int i=1;i<=n;i++)
    {	// 利用到 本次和上次 的更新的 f 数组
        for(int j=0;j<=m;j++)
        {	// 不选第 i 个物品,直接继承上次的更新的结果无需变化
        	// 选第 i 个物品,更新 f 数组
            if(j>=v[i])
                f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m];
    return 0;
}
  // 终极版本  时间复杂度:Θ(V∗N)  空间复杂度:Θ(V)
#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int f[N];
int v[N],w[N];
int n,m;
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)   cin>>v[i]>>w[i];
    for(int i=1;i<=n;i++)
    {	// 利用到 本次和上次 的更新的 f 数组
    	// 由 一次优化 得,直接从 v[i] 更新即可
        for(int j=v[i];j<=m;j++)
        {
            f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m];
    return 0;
}

多重背包

N N N 种物品和一个容量是 V V V 的背包。
i i i 种物品最多有 s i s_i si 件,每件体积是 v i v_i vi,价值是 w i w_i wi
求解将哪些物品装入背包,可使物品体积总和不超过背包容量,且价值总和最大。
输出最大价值。
输入格式
第一行两个整数, N , V N,V NV,用空格隔开,分别表示物品种数和背包容积。
接下来有 N N N 行,每行三个整数 v i , w i , s i v_i, w_i, s_i vi,wi,si,用空格隔开,分别表示第 i i i 种物品的体积、价值和数量。

输出格式
输出一个整数,表示最大价值。
数据范围
1.
0 < N , V ≤ 100 0 \lt N, V \le 100 0<N,V100
0 < v i , w i , s i ≤ 100 0 \lt v_i, w_i, s_i \le 100 0<vi,wi,si100

0 < N ≤ 1000 0 \lt N \le 1000 0<N1000
0 < V ≤ 2000 0 \lt V \le 2000 0<V2000
0 < v i , w i , s i ≤ 2000 0 \lt v_i, w_i, s_i \le 2000 0<vi,wi,si2000

  1. 0 < N ≤ 1000 0 \lt N \le 1000 0<N1000
    0 < V ≤ 20000 0 \lt V \le 20000 0<V20000
    0 < v i , w i , s i ≤ 20000 0 \lt v_i, w_i, s_i \le 20000 0<vi,wi,si20000
    输入样例
4 5
1 2 3
2 4 1
3 4 3
4 5 2

输出样例

10

代码

// 对应 数据1 暴力法,直接枚举每种物品对应的选择 0~s[i] 次,01背包的思路
// 时间复杂度:Θ(V∗∑s[i])
#include<bits/stdc++.h>
using namespace std;
int f[1010][1010],v[1010],w[1010],s[1010];
int main()
{
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++)   cin>>v[i]>>w[i]>>s[i];
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            for(int k=0;k<=s[i]&&k*v[i]<=j;k++)
            {
                f[i][j]=max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
            }
        }
    }
    cout<<f[n][m];
    return 0;
}

// 对应 数据2 二进制优化(倍增式优化)
// 时间复杂度Θ (N∗log(s)∗V)
// 任意非负数都可以用 二进制 的表示,(简单解释,十进制数能转化成二进制数)
#include<bits/stdc++.h>
using namespace std;
const int N=2e5+10;
int n,m;
int f[N];
int v[N],w[N],cnt;
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int a,b,s;cin>>a>>b>>s;
        int t=1;
        // 将每种情况的 2的幂次方 倍造成新的数据,多出的直接也是造成新的数据
        // 多出的 1 2 4 8 ... 2^x s-2^x
        while(t<=s)
        {
            cnt++;
            v[cnt]=a*t;
            w[cnt]=b*t;
            s-=t;
            t*=2;
        }
        if(s>0)
        {
            cnt++;
            v[cnt]=a*s;
            w[cnt]=b*s;
        }
    }
    // 重新定义新的 物品种类
    n=cnt;
    // 01背包
    for(int i=1;i<=n;i++)
    {
        for(int j=m;j>=v[i];j--)
        {
            f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m];
    return 0;
}
// 对应 数据3 终极版本
// 时间复杂度为Θ(V∗N)
// 利用单调队列
#include<bits/stdc++.h>
using namespace std;
const int N=2e5+10;
int n,m;
int f[N],g[N],q[N];
int main()
{
	cin>>n>>m;
	for(int i = 0; i < n; i++ )
	{
		int v, w, s;
		cin >> v >> w >> s;
		memcpy(g, f, sizeof f);
		for(int j = 0; j < v; j++) // 余数
		{
			int hh=0,tt=-1;
			for(int k=j;k<=m;k+=v)
			{
				 // 维护队列元素的个数,如果不能继续入队,弹出队头元素
				if(hh<=tt &&q[hh]<k-s*v)
                    hh++;
				 // 更新最大值
				if(hh<=tt)
                    f[k]=max(f[k],g[q[hh]]+(k-q[hh])/v*w);
				 // 维护队列的单调性
				while(hh<=tt&&g[q[tt]]-(q[tt]-j)/v*w<=g[k]-(k-j)/v*w)
                    tt--;
				 // 当前元素入队
				q[++tt]=k;
			}
		}
	}
	cout<<f[m];
	return 0;
}

混合背包

N N N 种物品和一个容量是 V V V 的背包。
物品一共有三类:

  • 第一类物品只能用1次(01背包);
  • 第二类物品可以用无限次(完全背包);
  • 第三类物品最多只能用 s i s_i si 次(多重背包);
    每种体积是 v i v_i vi,价值是 w i w_i wi
    求解将哪些物品装入背包,可使物品体积总和不超过背包容量,且价值总和最大。
    输出最大价值。
    输入格式
    第一行两个整数, N , V N,V NV,用空格隔开,分别表示物品种数和背包容积。
    接下来有 N N N 行,每行三个整数 v i , w i , s i v_i, w_i, s_i vi,wi,si,用空格隔开,分别表示第 i i i 种物品的体积、价值和数量。
  • s i = − 1 s_i = -1 si=1 表示第 i i i 种物品只能用1次;
  • s i = 0 s_i = 0 si=0 表示第 i i i 种物品可以用无限次;
  • s i > 0 s_i >0 si>0 表示第 i i i 种物品可以使用 s i s_i si 次;
    输出格式
    输出一个整数,表示最大价值。
    数据范围
    0 < N , V ≤ 1000 0 \lt N, V \le 1000 0<N,V1000
    0 < v i , w i ≤ 1000 0 \lt v_i, w_i \le 1000 0<vi,wi1000
    − 1 ≤ s i ≤ 1000 -1 \le s_i \le 1000 1si1000
    输入样例
4 5
1 2 -1
2 4 1
3 4 0
4 5 2

输出样例

8

代码

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int n,m;
int f[N];
int main()
{
	cin>>n>>m;
	for(int i=0;i<n;i++)
	{
		int v,w,s;cin>>v>>w>>s;
		if(s==0) // 01背包
		{
			for(int j=v;j<=m;j++)
				f[j]=max(f[j],f[j-v]+w);
		}
		else
		{    // 二进制转化成01背包
			if(s==-1)	s=1;
			for(int k=1;k<=s;k*=2)
			{
				for(int j=m;j>=k*v;j--)
					f[j]=max(f[j],f[j-k*v]+k*w);
				s-=k;
			}
			if(s)
			{
				for(int j=m;j>=s*v;j--)
					f[j]=max(f[j],f[j-s*v]+s*w);
			}
		}
	}
	cout<<f[m];
	return 0;
}

二维费用的背包问题

N N N 件物品和一个容量是 V V V 的背包,背包能承受的最大重量是 M M M

每件物品只能用一次。体积是 v i v_i vi,重量是 m i m_i mi,价值是 w i w_i wi

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

输入格式

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

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

输出格式

输出一个整数,表示最大价值。

数据范围

0 < N ≤ 1000 0 \lt N \le 1000 0<N1000
0 < V , M ≤ 100 0 \lt V, M \le 100 0<V,M100
0 < v i , m i ≤ 100 0 \lt v_i, m_i \le 100 0<vi,mi100
0 < w i ≤ 1000 0 \lt w_i \le 1000 0<wi1000

输入样例

4 5 6
1 2 3
2 4 4
3 4 5
4 5 6

输出样例

8

代码

// 本质是 两个体积限制 的01背包
#include<bits/stdc++.h>
using namespace std;
const int N=2020;
int f[N][N];
int n,s,m;
int main()
{
    cin>>n>>s>>m;
    for(int i=1;i<=n;i++)
    {
        int v,h,w;cin>>v>>h>>w;
        for(int j=s;j>=v;j--)
        {
            for(int k=m;k>=h;k--)
            {
                f[j][k]=max(f[j][k],f[j-v][k-h]+w);
            }
        }
    }
    cout<<f[s][m];
    return 0;
}

分组背包问题

N N N 组物品和一个容量是 V V V 的背包。

每组物品有若干个,同一组内的物品最多只能选一个。
每件物品的体积是 v i j v_{ij} vij,价值是 w i j w_{ij} wij,其中 i i i 是组号, j j j 是组内编号。

求解将哪些物品装入背包,可使物品总体积不超过背包容量,且总价值最大。

输出最大价值。

输入格式

第一行有两个整数 N , V N,V NV,用空格隔开,分别表示物品组数和背包容量。

接下来有 N N N 组数据:

  • 每组数据第一行有一个整数 S i S_i Si,表示第 i i i 个物品组的物品数量;
  • 每组数据接下来有 S i S_i Si 行,每行有两个整数 v i j , w i j v_{ij}, w_{ij} vij,wij,用空格隔开,分别表示第 i i i 个物品组的第 j j j 个物品的体积和价值;

输出格式

输出一个整数,表示最大价值。

数据范围

0 < N , V ≤ 100 0 \lt N, V \le 100 0<N,V100
0 < S i ≤ 100 0 \lt S_i \le 100 0<Si100
0 < v i j , w i j ≤ 100 0 \lt v_{ij}, w_{ij} \le 100 0<vij,wij100

输入样例

3 5
2
1 2
2 4
1
3 4
1
4 5

输出样例

8

代码

 // 01背包,枚举每组的所有的情况
#include<bits/stdc++.h>
using namespace std;
const int N=110;
int v[N][N],w[N][N],s[N];
int f[N];
int n,m;
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>s[i];
        for(int j=0;j<s[i];j++)
        {
            cin>>v[i][j]>>w[i][j];
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=m;j>=0;j--)
        {
            for(int k=0;k<s[i];k++)
            {
                if(v[i][k]<=j) f[j]=max(f[j],f[j-v[i][k]]+w[i][k]);
            }
        }
    }
    cout<<f[m];
    return 0;
}

有依赖的背包问题

N N N 个物品和一个容量是 V V V 的背包。

物品之间具有依赖关系,且依赖关系组成一棵树的形状。如果选择一个物品,则必须选择它的父节点。

如下图所示:
QQ图片20181018170337.png

如果选择物品5,则必须选择物品1和2。这是因为2是5的父节点,1是2的父节点。

每件物品的编号是 i i i,体积是 v i v_i vi,价值是 w i w_i wi,依赖的父节点编号是 p i p_i pi。物品的下标范围是 1 … N 1 … N 1N

求解将哪些物品装入背包,可使物品总体积不超过背包容量,且总价值最大。

输出最大价值。

输入格式

第一行有两个整数 N , V N,V NV,用空格隔开,分别表示物品个数和背包容量。

接下来有 N N N 行数据,每行数据表示一个物品。
i i i 行有三个整数 v i , w i , p i v_i, w_i, p_i vi,wi,pi,用空格隔开,分别表示物品的体积、价值和依赖的物品编号。
如果 p i = − 1 p_i = -1 pi=1,表示根节点。 数据保证所有物品构成一棵树。

输出格式

输出一个整数,表示最大价值。

数据范围

1 ≤ N , V ≤ 100 1 \le N, V \le 100 1N,V100
1 ≤ v i , w i ≤ 100 1 \le v_i, w_i\le 100 1vi,wi100

父节点编号范围:

  • 内部结点: 1 ≤ p i ≤ N 1 \le p_i \le N 1piN;
  • 根节点 p i = − 1 p_i = -1 pi=1;

输入样例

5 7
2 3 -1
2 2 1
3 5 1
4 7 2
3 6 2

输出样例

11

代码

// 代码1
// 要求选择子节点必须选择父节点,逆向思路,从根节点开始(因为根节点必须选择)广搜
// 每次都选择 点u ,遍历子节点
#include<bits/stdc++.h>
using namespace std;
const int N=110;
int n,m;
int v[N],w[N];
int h[N],e[N],ne[N],idx;
int f[N][N]; // f[i][j] 以 i点 为子节点,体积不超过 j 的最大值
void add(int a,int b)
{
	e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void dfs(int u)
{
	for(int i=h[u];i!=-1;i=ne[i])
	{
		int son=e[i];
		dfs(e[i]); // 遍历子节点
		for(int j=m-v[u];j>=0;j--) // m-v[i] 保证选择 当前根节点 u
			for(int k=0;k<=j;k++)
				f[u][j]=max(f[u][j],f[u][j-k]+f[son][k]);
	}
	for(int i=m;i>=v[u];i--)    f[u][i]=f[u][i-v[u]]+w[u];
	for(int i=0;i<v[u];i++) f[u][i]=0;
}
int main()
{
	cin>>n>>m;
	memset(h,-1,sizeof h); // 初始化
	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];
	return 0;
}
// 代码2
#include<bits/stdc++.h>
using namespace std;
int f[110][110];//f[u][v]表达选择以 点u 为子树的物品,在体积不超过 v 时所获得的最大价值
vector<int>g[110];
int v[110],w[110];
int n,m,root;
int dfs(int u)
{
    for(int i=v[u];i<=m;i++) f[u][i]=w[u];// 点u 必须选,所以初始化f[u][v[u] ~ m]= w[u]
    for(int i=0;i<g[u].size();i++)
    {
        int y=g[u][i];
        dfs(y);
        for(int j=m;j>=v[u];j--)// j 的范围为v[u]~m, 小于v[u]无法选择以 点u 为子树的物品
        {
            for(int k=0;k<=j-v[u];k++)//分给子树y的空间不能大于j-v[u],不然都无法选根物品u
            {
                f[u][j]=max(f[u][j],f[u][j-k]+f[y][k]);
            }
        }
    }
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int p;
        cin>>v[i]>>w[i]>>p;
        if(p==-1)
            root=i;
        else
            g[p].push_back(i);
    }
    dfs(root);
    cout<<f[root][m];
    return 0;
}

背包问题求方案数

N N N 件物品和一个容量是 V V V 的背包。每件物品只能使用一次。

i i i 件物品的体积是 v i v_i vi,价值是 w i w_i wi

求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。

输出 最优选法的方案数。注意答案可能很大,请输出答案模 1 0 9 + 7 10^9 + 7 109+7 的结果。

输入格式

第一行两个整数, N , V N,V NV,用空格隔开,分别表示物品数量和背包容积。

接下来有 N N N 行,每行两个整数 v i , w i v_i, w_i vi,wi,用空格隔开,分别表示第 i i i 件物品的体积和价值。

输出格式

输出一个整数,表示 方案数 1 0 9 + 7 10^9 + 7 109+7 的结果。

数据范围

0 < N , V ≤ 1000 0 \lt N, V \le 1000 0<N,V1000
0 < v i , w i ≤ 1000 0\lt v_i, w_i \le 1000 0<vi,wi1000

输入样例

4 5
1 2
2 4
3 4
4 6

输出样例

2

代码

 // 根据 01背包 状态转移方程 f[j]=max(f[j],f[j-v]+w)得
 // 方案数也随 f[j] 的转移而转移
 // 1. f[j-v]+w > f[j] , g[j]=g[j-v]
 // 2. f[j-v]+w == f[j], g[j]=( g[j] + g[j-v] )
#include<bits/stdc++.h>
using namespace std;
const int mod=1e9+7;
int f[1010],g[1010];
int main()
{
	int n,m;cin>>n>>m;
    fill(g,g+m+1,1); // 初始化 g 数组内元素为 1
	for(int i=0;i<n;i++)
	{
		int v,w;cin>>v>>w;
		for(int j=m;j>=v;j--)
		{
			int va=f[j-v]+w;
			if(va>f[j])
			{
				f[j]=va;
				g[j]=g[j-v];
			}
			else if(va==f[j])
			{
				g[j]=(g[j]+g[j-v])%mod;
			}
		}
	}
	cout<<g[m];
	return 0;
}

背包问题求具体方案

N N N 件物品和一个容量是 V V V 的背包。每件物品只能使用一次。

i i i 件物品的体积是 v i v_i vi,价值是 w i w_i wi

求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。

输出 字典序最小的方案。这里的字典序是指:所选物品的编号所构成的序列。物品的编号范围是 1 … N 1 … N 1N

输入格式

第一行两个整数, N , V N,V NV,用空格隔开,分别表示物品数量和背包容积。

接下来有 N N N 行,每行两个整数 v i , w i v_i, w_i vi,wi,用空格隔开,分别表示第 i i i 件物品的体积和价值。

输出格式

输出一行,包含若干个用空格隔开的整数,表示最优解中所选物品的编号序列,且该编号序列的字典序最小。

物品编号范围是 1 … N 1 … N 1N

数据范围

0 < N , V ≤ 1000 0 \lt N, V \le 1000 0<N,V1000
0 < v i , w i ≤ 1000 0\lt v_i, w_i \le 1000 0<vi,wi1000

输入样例

4 5
1 2
2 4
3 4
4 6

输出样例

1 4

代码

 // 逆向思路,输出字典序小的物品编号
 // 倒序 01背包,
 // 假设存在一个包含第1个物品的最优解,我们一定会选第一个。
 // 问题就转化成从2~N这些物品中找到最优解。
#include<iostream>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N];
int f[N][N]; // 二维数组便于求出最后答案
int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)	cin>>v[i]>>w[i];
	// 倒序 01背包
	for(int i=n;i>=1;i--)
	{
		for(int j=0;j<=m;j++)
		{
			f[i][j]=f[i+1][j];
			if(j>=v[i])
				f[i][j]=max(f[i][j],f[i+1][j-v[i]]+w[i]);
		}
	}
	int j=m;
	for(int i=1;i<=n;i++)
	{
		if(j>=v[i]&&f[i][j]==f[i+1][j-v[i]]+w[i])
		{
			cout<<i<<' ';
			j-=v[i]; // 选择第 i 个物品,总体积变小 
		}
	}
	return 0;
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/2054945.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

影刀工程师认证考试_考试试题_初级_影刀IT速成课程_操作题_题型D

下载待查询表格.xlsx表格至本地&#xff08;手动操作&#xff09;启动“待查询订单.xlsx”表格打开影刀商城——订单管理页面 影刀商城 循环查询“Sheet1”中的所有订单编号&#xff1a;搜索当前循环到的订单号使用【获取相似元素列表(web)】获取该订单的全部信息根据查询结果…

解密巴黎奥运会中的阿里云AI技术

引言 终于&#xff0c;2024年巴黎奥运会也是圆满落幕了&#xff0c;中国体育代表团的表现极为出色&#xff0c;金牌数位居世界第二&#xff08;与美国并列第一&#xff09;&#xff0c;运动员们在多个项目中展现了非凡的实力和拼搏精神&#xff0c;为中国赢得了荣誉。从射击项…

银河麒麟V10如何安装本地deb软件包?(以安装wps为例)

银河麒麟V10如何安装本地deb软件包&#xff1f;&#xff08;以安装wps为例&#xff09; 一、准备二、安装三、总结 &#x1f496;The Begin&#x1f496;点点关注&#xff0c;收藏不迷路&#x1f496; 在银河麒麟V10中安装本地.deb软件包&#xff0c;虽然apt主要用于管理仓库中…

【Hadoop】核心组件深度剖析:HDFS、YARN与MapReduce的奥秘

&#x1f407;明明跟你说过&#xff1a;个人主页 &#x1f3c5;个人专栏&#xff1a;《大数据前沿&#xff1a;技术与应用并进》&#x1f3c5; &#x1f516;行路有良友&#xff0c;便是天堂&#x1f516; 目录 一、引言 1、Hadoop简介 2、Hadoop生态系统概览 二、Hadoo…

【C++ 第十三章】AVL 二叉平衡树

1. AVL树的概念 普通二叉搜索树虽可以缩短查找的效率&#xff0c;但如果数据有序或接近有序二叉搜索树将退化为单支树&#xff0c;查找元素相当于在顺序表中搜索元素&#xff0c;效率低下。 因此&#xff0c;两位俄罗斯的数学家 G.M.Adelson-Velskii 和 E.M.Landis 在1962年发明…

【故障处理】- ping不通的原因

PING不通是一个非常常见的网络问题&#xff0c;它可能由多种原因引起。如链路故障、ARP学习失败等 以一个Ping不通的尝试示例&#xff0c;介绍Ping不通故障的定位思路。如下图&#xff1a; PC3 Ping不通PC4 PC>ping 20.1.1.20Ping 20.1.1.20: 32 data bytes, Press Ctrl_C…

产品经理-​​实习中的自我迭代(41)

实习中的自我迭代,优秀实习生必备素质 跟大家认识了之后&#xff0c;就要开始做事情了&#xff0c;那我们怎么做一个优秀的实习生呢&#xff1f;以下几点作为参考。 1. 目标明确 知道自己的工作为什么要做&#xff0c;要做到什么程度&#xff0c;目前存在什么问题&#xff0c;该…

初探:c++异步编程之std::promise和std::future【异步数据获取】

c异步编程之std::promise和std::future 1.std::future获取std::asnyc结果2.模拟一个异步函数接口i.模拟一个客户端类包含异步请求接口ii.调用异步接口获取结果 c11以后标准库提供了thread&#xff0c;说起异步可能会第一时间想起thread&#xff0c;线程确实好东西&#xff0c;不…

2023年人均GDP百强市分布图

2023年人均GDP百强市分布图

redis安装,redis的数据类型和使用场景,Redis事务,Redis持久化,Redis淘汰策略

Redis简介 https://redis.io/docs/data-types/ Redis&#xff08;Remote Dictionary Server )远程字典服务&#xff0c;是一个开源的使用ANSI C语言编写、支持网络、可基于内存也可持久化的日志型、Key-Value(NoSQL)数据库。 Redis的特点 性能极高&#xff0c;基于内存&…

ORACLE ADG 主库的归档日志不能主动传递到备库

主库有三个节点 &#xff0c;其中两个节点传递没有问题&#xff0c;唯独节点二的归档日志不能主动传递到备库&#xff0c;都是在备库恢复需要的时候一个个传递到备库。下面是备库的日志。 Media Recovery Waiting for thread 2 sequence 1204582 …

SAP和致远OA系统集成案例

一、项目介绍 重庆某控股&#xff08;集团&#xff09;有限公司是一家集合汽柴油动力及终端、摩托车、储能电源、汽车零部件、金融服务等产业的多元化集团公司&#xff0c;业务遍布全球80多个国家及地区&#xff0c;2021年营业收入达80亿元。 为推动集团信息化、数字化转型…

基于WonderJourney生成电影级连续的3D场景视频

在本文中,我将详细记录在Windows环境下配置和使用WonderJourney项目的完整流程,包括环境搭建、常见问题的解决方案以及如何修改源码以兼容Windows系统。WonderJourney项目能够生成高度逼真的村庄视频,并允许用户通过配置文件对视频生成过程进行精细化控制。 由于官方文档在…

选型指南:CNAPP能力成熟度评估Checklist

随着云计算服务大量使用&#xff0c;网络攻击面的不断扩大&#xff0c;那些过去为传统数据中心而设计的安全工具和运营流程将很难应对云端的安全威胁。相比过去&#xff0c;安全团队现在面临超过10到100倍的容器化保护需求&#xff0c;大量的动态云资产需要追踪&#xff0c;同时…

MySQL 在 Windows 和 Ubuntu 上的安装与远程连接配置简介

MySQL 是一个广泛使用的开源关系型数据库管理系统&#xff0c;它提供了多用户、多线程的数据库服务。本文将介绍如何在 Windows 和 Ubuntu 操作系统上安装 MySQL&#xff0c;并配置远程连接。 Windows 上的 MySQL 安装 1. 下载 MySQL Installer 访问 MySQL 官方网站下载 Win…

c++--类(上)

C之类&#xff08;上&#xff09; 一、类的定义1.1 类定义格式1.2 访问限定符1.3 类域 二、实例化2.1 实例化的概念2.2 对象大小 三、this指针 一、类的定义 1.1 类定义格式 1、class为定义类的关键字&#xff0c;{}中为类的主体&#xff0c;注意类定义结束时后⾯分号不能省略…

Ollama - Llama3 docker版本安装部署使用

项目地址&#xff1a;https://github.com/meta-llama/llama3 Meta 发布两款开源Llama 3 8B与Llama 3 70B模型&#xff0c;供外部开发者免费使用。Llama 3的这两个版本&#xff0c;也将很快登陆主要的云供应商。 按照Meta的说法&#xff0c;Llama 3 8B和Llama 3 70B是目前同体量…

threejs中实现物体阴影

在Three.js中实现阴影需要几个步骤&#xff0c;包括设置渲染器、光源以及物体的材质等。以下是一个基本的实现阴影的步骤&#xff1a; 1、设置渲染器以支持阴影&#xff1a; const renderer new THREE.WebGLRenderer(); renderer.setSize(window.innerWidth, window.innerH…

三大运营管理平台:打造智能化新能源数据管理的核心利器

随着全球能源结构的转型和新能源技术的快速发展&#xff0c;智能化新能源数据管理成为行业发展的关键。三大运营管理平台的出现&#xff0c;正是为了解决这一需求&#xff0c;它们通过整合先进的信息技术和智能算法&#xff0c;为新能源企业提供了全面、高效、精准的数据管理解…

告别帕金森手抖,这些维生素是你的秘密武器!

亲们&#xff0c;你们有没有遇到过这样的情况&#xff1f;家里的长辈或是自己&#xff0c;偶尔会出现手不自觉颤抖的现象&#xff0c;特别是被诊断为帕金森病的朋友&#xff0c;更是深受其扰。&#x1f614; 别担心&#xff0c;今天就来聊聊如何通过科学补充一些关键维生素&…