背包问题至多，至少，恰好问题的研究

已于 2023-04-07 09:44:05 修改
阅读量1k 收藏 36
点赞数 15
分类专栏： C++ 动态规划DP 文章标签： 深度优先 动态规划 算法
于 2022-02-27 01:17:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52765554/article/details/123157907
版权

写在开头：
本文参考：https://www.acwing.com/blog/content/458/
仅作为笔记使用

目录

Ⅰ. 结论

一. 求方案数初始化总结

1. 二维情况

  1. 体积至多是j，f[0][i]=1,0<=i<=m，其余是0
  2. 体积恰好是j，f[0][0]=1，其余是0
  3. 体积至少j，f[0][0]=1,其余是0

2. 一维情况

  1. 体积至多j，f[i]=1，0<=i<=m
  2. 体积恰好j,f[0]=1，其余是0
  3. 体积至少j，f[0]=1,其余是0

求最大值和最小值初始化总结

1. 二维情况

  1. 体积至多是j，f[i,k]=0,0<=i<=m,0<=k<=m
  2. 体积恰好是j，
    当前价值的最小值：f[0][0]=0，其余是INF
    当求价值的最大值:f[0][0]=0，其余是-INF
  3. 体积至少j,f[0][0]=0，其余是INF （只会求价值最小值）

2. 一维情况

  1. 体积至多j，f[i]=0，0<=i<=m（只会求价值的最大值）
  2. 体积恰好j
    当求价值的最小值：f[0]=0，其余是INF
    当求价值的最大值:f[0]=0，其余是-INF
  3. 体积至少j，f[0]=0，其余是INF（只 会求价值最小值）

Ⅱ . 具体问题

一. 求方案数问题

  1. 从前i个物品中选，总体积不超过j的总方案数,初始化f[0][i]=1，0<=i<=m其余是0
    01背包
    每个物品有一定的体积，只能选一次，求总体积不超过m的方案数
    二维code
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int f[N][N];
int n, m;
int main()
{
	cin >> n >> m;
	for (int i = 0; i <= m; i++)f[0][i] = 1;
	for (int i = 1; i <= n; i++)
	{
		int v;
		cin >> v;
		for (int j = 0; j <= m; j++)
		{
			f[i][j] = f[i - 1][j];
			if (j >= v)f[i][j] += f[i - 1][j - v];
		}
	}
	cout << f[n][m] << endl;
	return 0;
}

一维code

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int f[N];
int n, m;
int main()
{
	cin >> n >> m;
	for (int i = 0; i <= m; i++)f[i] = 1;
	for (int i = 1; i <= n; i++)
	{
		int v;
		cin >> v;
		for (int j = m; j >= v; j--)
			f[j] += f[j - v];
	}
	cout << f[m] << endl;
	return 0;
}

完全背包
给你一堆物品，每个物品有一定的体积，每个物品可以选无数多个，总体积不超过m的方案数
二维code

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m;
int f[N][N];
int main()
{
    cin >> n >> m;
    for (int i = 0; i <= m; i++) f[0][i] = 1;
    for (int i = 1; i <= n; i++)
    {
        int v;
        cin >> v;
        for (int j = 0; j <= m; j++)
        {
            f[i][j] = f[i - 1][j];
            if (j >= v) f[i][j] += f[i][j - v];
        }
    }
    cout << f[n][m] << endl;
    return 0;
}

一维code

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m;
int f[N];
int main()
{
    cin >> n >> m;
    for (int i = 0; i <= m; i++) f[i] = 1;
    for (int i = 1; i <= n; i++)
    {
        int v;
        cin >> v;
        for (int j = v; j <= m; j++)
            f[j] += f[j - v];
    }
    cout << f[m] << endl;

    return 0;
}
  1. 从前 i 个物品中选，且总体积恰好是j的方案数,初始化为f[0][0]=1其余是0

01背包
给你一堆物品，每个物品有一定的体积，每个物品只能选一个，求总体积恰好是m的方案数
二维code

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m;
int f[N][N];
int main()
{
    cin >> n >> m;
    f[0][0] = 1;
    for (int i = 1; i <= n; i++)
    {
        int v;
        cin >> v;
        for (int j = 0; j <= m; j++)
        {
            f[i][j] = f[i - 1][j];
            if (j >= v)f[i][j] += f[i - 1][j - v];
        }
    }
    cout << f[n][m] << endl;

    return 0;
}

一维code

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m;
int f[N];
int main()
{
    cin >> n >> m;
    f[0] = 1;
    for (int i = 1; i <= n; i++)
    {
        int v;
        cin >> v;
        for (int j = m; j >= v; j--)
        {
            f[j] += f[j - v];
        }
    }
    cout << f[m] << endl;

    return 0;
}

完全背包
给你一堆物品，每个物品有一定的体积，每个物品可以选无数多个，求总体积恰好是m的方案数
二维code

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m;
int f[N][N];
int main()
{
    cin >> n >> m;
    f[0][0] = 1;
    for (int i = 1; i <= n; i++)
    {
        int v;
        cin >> v;
        for (int j = 0; j <= m; j++)
        {
            f[i][j] = f[i - 1][j];
            if(j>=v)f[i][j] += f[i][j - v];
        }
    }
    cout << f[n][m] << endl;

    return 0;
}

一维code

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m;
int f[N];
int main()
{
    cin >> n >> m;
    f[0] = 1;
    for (int i = 1; i <= n; i++)
    {
        int v;
        cin >> v;
        for (int j = v; j <= m; j++)
        {
            f[j] += f[j - v];
        }
    }
    cout << f[m] << endl;
    return 0;
}
  1. 从前i个物品中选，总体积至少是j的总方案数，初始化f[0][0]=1,其余至少是0,至少的情况，j需要从0枚举到m，或者从m枚举到0）
    01背包
    给你一堆物品，每个物品有一定的体积，每个物品只能选一个，求总体积至少是m的方案数
#include <iostream>

using namespace std;

const int N = 110;

int n, m;
int f[N][N];

int main()
{
    cin >> n >> m;
    f[0][0] = 1;
    for (int i = 1; i <= n; i++)
    {
        int v;
        cin >> v;
        for (int j = 0; j <= m; j++)//即使物品体积比j大，j - v < 0，也能选，等价于f[i - 1][0]
        {
            f[i][j] = f[i - 1][j] + f[i - 1][max(0, j - v)];
        }
    }
    cout << f[n][m] << endl;

    return 0;
}

一维code

#include <iostream>

using namespace std;

const int N = 110;

int n, m;
int f[N];

int main()
{
    cin >> n >> m;
    f[0] = 1;
    for (int i = 1; i <= n; i++)
    {
        int v;
        cin >> v;
        for (int j = m; j >= 0; j--)//即使物品体积比j大，j - v < 0，也能选，等价于f[i - 1][0]
        {
            f[j] += f[max(0, j - v)];
        }
    }
    cout << f[m] << endl;

    return 0;
}

二. 求最大值最小值问题

  1. 从前i个物品中选，且总体积不超过j的最大价值，初始化是f[i,k] = 0，0 <= i <= n, 0 <= k <= m（只会求价值的最大值）

01背包问题
给你一堆物品，每个物品有一定的体积和对应的价值，每个物品只能选一个，求总体积不超过m的最大价值
二维code

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int f[N][N];
int n, m;
int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
	{
		int w, v;
		cin >> v >> w;
		for (int j = 0; j <= m; j++)
		{
			f[i][j] = f[i - 1][j];
			if (j >= v)f[i][j] = max(f[i][j], f[i - 1][j - v] + w);
		}
	}
	cout << f[n][m] << endl;
	return 0;
}

一维code

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int f[N];
int n, m;
int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
	{
		int w, v;
		cin >> v >> w;
		for (int j = m; j >= v; j--)
		{
			f[j] = max(f[j], f[j - v] + w);
		}
	}
	cout << f[m] << endl;
	return 0;
}
  1. 从前i个物品中选，且总体积恰好是j
    求价值最小值：初始化f[0][0] = 0, 其余是INF
    01背包
    给你一堆物品，每个物品有一定的体积和对应的价值，每个物品只能选一个，求总体积恰好是j的最小价值
    二维code
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int f[N][N];
int n, m;
int main()
{
	cin >> n >> m;
	memset(f, 0x3f, sizeof f);
	f[0][0] = 0;
	for (int i = 1; i <= n; i++)
	{
		int v, w;
		cin >> v >> w;
		for (int j = 0; j <= m; j++)
		{
			f[i][j] = f[i - 1][j];
			if (j >= v)f[i][j] = min(f[i][j], f[i - 1][j - v] + w);
		}
	}
	cout << f[n][m] << endl;
	return 0;
}

一维code

#include <bits/stdc++.h>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, m;
int f[N];

int main()
{
    cin >> n >> m;

    memset(f, INF, sizeof f);
    f[0] = 0;

    for(int i = 1;i <= n;i ++)
    {
        int v, w;
        cin >> v >> w;
        for(int j = m;j >= v;j --)
        {
            f[j] = min(f[j], f[j - v] + w);
        }
    }

    cout << f[m] << endl;

    return 0;
}
  1. 求价值最大值：初始化f[0][0] = 0, 其余是-INF
    给你一堆物品，每个物品有一定的体积和对应的价值，每个物品只能选一个，求总体积恰好是j的最大价值
    二维code
#include <bits/stdc++.h>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, m;
int f[N][N];

int main()
{
    cin >> n >> m;

    memset(f, -INF, sizeof f);
    f[0][0] = 0;

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

    cout << f[n][m] << endl;

    return 0;
}

一维code

#include <iostream>
#include <cstring>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, m;
int f[N];

int main()
{
    cin >> n >> m;

    memset(f, -INF, sizeof f);
    f[0] = 0;

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

    cout << f[m] << endl;

    return 0;
}

完全背包

  1. 求价值最小值：初始化f[0][0] = 0, 其余是INF
    给你一堆物品，每个物品有一定的体积和对应的价值，每个物品可以选无数多个，求总体积恰好是j的最小价值
#include <bits/stdc++.h>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, m;
int f[N][N];

int main()
{
    cin >> n >> m;

    memset(f, INF, sizeof f);
    f[0][0] = 0;

    for (int i = 1; i <= n; i++)
    {
        int v, w;
        cin >> v >> w;
        for (int j = 0; j <= m; j++)
        {
            f[i][j] = f[i - 1][j];
            if (j >= v) f[i][j] = min(f[i][j], f[i][j - v] + w);
        }
    }

    cout << f[n][m] << endl;

    return 0;
}

一维code

#include <bits/stdc++.h>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, m;
int f[N];

int main()
{
    cin >> n >> m;

    memset(f, INF, sizeof f);
    f[0] = 0;

    for (int i = 1; i <= n; i++)
    {
        int v, w;
        cin >> v >> w;
        for (int j = v; j <= m; j++)
        {
            f[j] = min(f[j], f[j - v] + w);
        }
    }
    cout << f[m] << endl;

    return 0;
}
  1. 求价值最大值：初始化f[0][0] = 0, 其余是-INF
    给你一堆物品，每个物品有一定的体积和对应的价值，每个物品可以选无数多个，求总体积恰好是j的最大价值
    二维code
#include <iostream>
#include <cstring>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, m;
int f[N][N];

int main()
{
    cin >> n >> m;

    memset(f, -INF, sizeof f);
    f[0][0] = 0;

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

    cout << f[n][m] << endl;

    return 0;
}

一维code

#include <iostream>
#include <cstring>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, m;
int f[N];

int main()
{
    cin >> n >> m;

    memset(f, -INF, sizeof f);
    f[0] = 0;

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

    cout << f[m] << endl;

    return 0;
}

3、从前i个物品中选，且总体积至少是j，初始化是f[0][0] = 0, 其余是INF（只会求价值的最小值）

例子：给你一堆物品，每个物品有一定的体积和对应的价值，每个物品可以选无数多个，求总体积至少是j的最小价值
二维code

#include <iostream>
#include <cstring>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, m;
int f[N][N];

int main()
{
    cin >> n >> m;

    memset(f, INF, sizeof f);
    f[0][0] = 0;

    for(int i = 1;i <= n;i ++)
    {
        int v, w;
        cin >> v >> w;
        for(int j = 0;j <= m;j ++)
        {
            f[i][j] = min(f[i - 1][j], f[i][max(0, j - v)] + w);//即使物品体积比j大，j - v < 0，也能选，等价于f[i - 1][0]
        }
    }

    cout << f[n][m] << endl;

    return 0;
}

一维code

#include <iostream>
#include <cstring>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, m;
int f[N];

int main()
{
    cin >> n >> m;

    memset(f, INF, sizeof f);
    f[0] = 0;

    for(int i = 1;i <= n;i ++)
    {
        int v, w;
        cin >> v >> w;
        for(int j = m;j >= 0;j --)
        {
            f[j] = min(f[j], f[max(0, j - v)] + w);//即使物品体积比j大，j - v < 0，也能选，等价于f[0]
        }
    }

    cout << f[m] << endl;

    return 0;
}
leimingzeOuO
关注
  • 15
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
3-增量背包问题四类实例
09-03
3-增量背包问题四类实例
背包问题Matlab求解
05-28
初始化背包容量、价值等必要因素，Matlab求解最优解。代码模块清晰，简单明了。
经典算法之—背包问题
呵呵
12-18 3011
一．完全背包问题 问题描述：有一个背包容量为M，一堆物品其重量表示为W={w(1),w(2),…}，物品相应的价值V={v(1),v(2),…}，现在要求将物品中的一部分或全部，放入背包。要求：装入物品的总价值最高；同时满足装入物品总重量不超过M；对单个物品而言，状态可为：装入背包、不装入背包、一部分装入背包。 假设装入的物品为从w(i)到w(j)，则有： 对于完全背包而言，我们采用
【动态规划】背包求最大最小价值问题
青年有志
05-04 4234
《经典算法之背包求最大最小价值问题》
【动态规划】背包问题（详细总结，很全）
热门推荐
m0_51370744的博客
10-07 2万+
暴力的解法是指数级别的时间复杂度。进而才需要动态规划的解法来进行优化！背包问题是动态规划（Dynamic Planning） 里的非常重要的一部分,关于几种常见的背包，其关系如下：在解决背包问题的时候，我们通常都是按照如下五部来逐步分析，把这五部都搞透了，算是对动规来理解深入了。二维dp数组01背包，先遍历物品还是先遍历背包都是可以的，且第二层for循环是从小到大遍历一维dp数组01背包，只能先遍历物品再遍历背包容量，且第二层for循环是从大到小遍历。求组合数：外层遍历物品，内层遍历背包。
【算法5.1】背包问题 - 01背包 （至多最大价值、至少最小价值）
weixin_61639349的博客
01-14 1481
01背包 至多至少模板 dp
C++背包问题——完全背包必须装满的方案数
小天狼星_布莱克 的博客
07-24 1733
想要了解，就得先了解，点击下面方框查看（）C++背包问题——完全背包_闪耀的天狼星的博客-CSDN博客一个旅行者有一个最多能装M公斤的背包，现在有n件物品，它们的重量分别是W1，W2，...,Wn,它们的价值分别为C1,C2,...,Cn，求旅行者能获得最大总价值。但每种物品的数量是无限的，同时有一个背包，最大载重量为M，今从n种物品中选取若干件(同一种物品可以多次选取)，使其重量的和小于等于M，而价值的和为最大。，再来看题目，顾名思义，背包必须装满（限制条件必须刚好满足）...
【dp】背包问题
YoungMLet的博客
10-06 800
背包问题是⼀种组合优化的问题。问题可以描述为：给定⼀组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。01背包问题：每个物品只有⼀个完全背包问题：每个物品有无限多个多重背包问题：每件物品最多有 x 个混合背包问题：每个物品会有上面三种情况分组背包问题：物品有 n 组，每组物品里有若干个，每组里最多选⼀个物品不一定装满背包背包一定装满限定条件只有⼀个：比如体积 -> 普通的背包问题限定条件有两个：比如体积 + 重量 -> 二维费用背包问题。
Piggy-Bank HDU - 1114（多重背包）
dsaghjkye的博客
05-10 619
在 ACM 能够开展之前，必须准备预算，并获得必要的财力支持。该活动的主要收入来自于 Irreversibly Bound Money (IBM)。思路很简单。任何时候，某位 ACM 会员有少量的钱时，他将所有的硬币投入到小猪储钱罐中。这个过程不可逆，因为只有把小猪储钱罐打碎才能取出硬币。在足够长的时间之后，小猪储钱罐中有了足够的现金，用于支付 ACM 活动所需的花费。但是，小猪储钱罐存在一个大的...
01背包问题
前景
03-22 832
最开始接触这道题是： 给定一个数组A(至少1个元素,最多50个元素,且101≤ A[is 300),A[i]表示第i个货物的重量。每个背包的最大容量为300。每个背包可装多个货物,但不能超过其容量。 输入:数组A 输出:能装下所有货物所需的最少背包数量。 这个题就很简单，只需要判断装入背包的货物的重量不超过容量即可（货物不可拆分） 思路：因为一个背包可以装多个货物，这时候就要看其装入的重量是多少了，这时候就需要用一个变量sum来保存了，然后再判断其是否超过最大容量，如果超过，那就需要装入别的袋子中。装入别
背包问题介绍背包问题.zip
03-21
背包问题
背包问题九讲html版本
最新发布
03-25
背包问题 背包问题九讲html版本
背包问题介绍1.zip
03-21
背包问题
背包问题详解（含代码）
林一百二十八的博客
11-10 4824
背包背包背包，动态规划啊
背包问题详解
承续缘的信仰
08-04 1万+
背包问题 背包问题(Knapsack problem)是一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的体积和价值，在限定的总体积内，我们如何选择，才能使得物品的总价值最高。问题的名称来源于如何选择最合适的物品放置于给定背包中。相似问题经常出现在商业、组合数学，计算机复杂理论、密码学和应用数学等领域中。也可以将背包问题描述为决定性问题，即在总体积不超过V的前提下，总价值
每周一算法：背包问题（五）求解方案数
少儿编程乔老师
12-06 599
每周一算法：背包问题（五）求解方案数。包含01背包、完全背包在不超过背包容量和恰好装满背包时的方案数。
对于背包问题的小总结！
weixin_51515308的博客
11-19 142
1、体积至多j，f[i,k] = 0，0
背包问题中的“至少至多恰好”问题
qq12323qweeqwe的博客
02-01 374
前言 对于背包问题的至少，至多，恰好问题，他们的状态转移方程其实是不变的，需要考虑的只有初始化的问题和一些特殊点的特判 这里的二维指的是没有状态优化的二维，而不是二维费用\ 求方案数初始化 二维情况 1、体积至多j，f[0][i] = 1, 0 <= i <= m，其余是0 2、体积恰好j，f[0][0] = 1, 其余是0 3、体积至少j，f[0][0] = 1，其余是0 状态转移max(0,..) 从状态定义的本身出发 一维情况 1、体积至...
【详解】leetcode每日一题(5.12)+codeforces杂题
qq_52765554的博客
05-12 6301
目录leetcode每日一题944. 删列造序codeforcesC. OKEAB. Roof ConstructionB. A Perfectly Balanced String? leetcode每日一题 944. 删列造序 思路： 枚举每一列查看是否递增即可 class Solution { public: int minDeletionSize(vector<string>& strs) { int res=0; int n=strs.s
python背包问题
08-26
背包问题是一个经典的优化问题，在计算机科学和运筹学中经常被讨论和研究。在Python中，可以使用动态规划来解决背包问题。 背包问题可以分为0-1背包问题和无限背包问题两种类型。 0-1背包问题要求在有限的物品集合中选择一些物品放入背包，使得在限定的背包容量下，所选物品的总价值最大化。每种物品只能选择取或不取一次。 无限背包问题则允许每种物品选择无限次放入背包，其他条件与0-1背包问题类似。 下面是一个简单的例子，展示如何使用动态规划解决0-1背包问题： ```python def knapsack_01(values, weights, total_weight): n = len(values) dp = [[0] * (total_weight + 1) for _ in range(n + 1)] for i in range(1, n + 1): for j in range(1, total_weight + 1): if weights[i - 1] <= j: dp[i][j] = max(dp[i - 1][j], values[i - 1] + dp[i - 1][j - weights[i - 1]]) else: dp[i][j] = dp[i - 1][j] return dp[n][total_weight] ``` 在这个例子中，`values`是物品的价值列表，`weights`是物品的重量列表，`total_weight`是背包的总容量。函数返回最大化的总价值。 你可以根据实际需求进行修改和扩展，这只是一个基本的示例。希望对你有所帮助！如果有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

leimingzeOuO

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值