数据结构笔记--背包问题

已于 2023-09-27 16:02:24 修改
阅读量335 收藏
点赞数 1
分类专栏： 数据结构&LeetCode 文章标签： 数据结构
于 2023-09-23 14:37:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43863869/article/details/133205334
版权

目录

1--0-1背包问题

2--分割等和子集

3--最后一块石头的重量II

4--目标和

5--一和零

6--完全背包问题

7--零钱兑换II

8--组合总和IV

9--零钱兑换

10--完全平方数

11--单词拆分

1--0-1背包问题

0-1 背包问题的特征：

        一共有 n 个物品，但每个物品只能选择一次；

二维 dp 解法：

        dp[i][j] 表示背包容量为 j ，可以在 0-i 种物品选取，其最大价值；

        初始化：dp[0][j] = value[0]（j >= weight[0]），dp[i][0] = 0；

        状态转移方程：dp[i][j] == std::max(dp[i-1][j], dp[i-1][j-weight[i]] + value[i])，其中 dp[i-1][j] 表示不选择物品 i，dp[i-1][j-weight[i]] + value[i] 表示选择物品 i；

        遍历顺序：两个 for 循环来正序遍历物品 i 和背包容量 j（可以先遍历物品 i，再遍历背包容量 j；也可以先遍历背包容量 j，再遍历物品 i）；

一维 dp 解法：

        dp[j] 表示背包容量为 j 时，其最大价值；

        初始化：dp[0] = 0；

        状态转移方程：dp[j] =  std::max(dp[j], dp[j - weight[i]] + value[i])，其中 dp[j - weight[i]] + value[i] 表示选取物品 i 时；

        遍历顺序：两个 for 循环，第一个 for 循环正序遍历物品，第二个 for 循环倒叙（j 从大到小）遍历背包容量；（不能先遍历背包容量，再遍历物品）；

2--分割等和子集

主要思路：

        可以转换为 0-1 背包问题，将一半的和作为背包的容量，另一半的和作为物品的价值，同时每个物品的价值和重量相同；

        计算背包的容量：target = sum / 2;

        初始化：dp[0] = 0;

        状态转移方程：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])；j 表示背包的容量，dp[j]表示背包容量为 j 时，背包所装物品的最大价值；

        遍历顺序：经典0-1背包一维遍历顺序，先正序遍历物品，再倒叙遍历背包容量；

        当 dp[target] == target 时，表明恰好可以将数组划分为两个子集，一个子集的和作为背包容量，另一个子集的和作为物品的价值；

#include <iostream>
#include <vector>

class Solution {
public:
    bool canPartition(std::vector<int>& nums) {
		int sum = 0;
		for(int num : nums){
			sum += num;
		}
		if(sum % 2 == 1) return false; // 不能二等分
		int target = sum / 2; // 一半和当作容量，另一半和作为价值
		std::vector<int> dp(target+1, 0);
		
		// 初始化
		dp[0] = 0;
		// 遍历
		for(int i = 0; i < nums.size(); i++){
			for(int j = target; j >= nums[i]; j--){ // j >= nums[i] 确保容量大于重量，这里物品的重量和价值相同，均为nums[i]
				dp[j] = std::max(dp[j], dp[j - nums[i]] + nums[i]);
			}
		}
		if(dp[target] == target) return true; // 一半作为容量，另一半作为价值，因此可以等分
		return false;
    }
};

int main(int argc, char *argv[]) {
	// nums = [1,5,11,5]
	std::vector<int> test = {1, 5, 11, 5};
	Solution S1;
	bool res = S1.canPartition(test);
	if(res) std::cout << "true" << std::endl;
	else std::cout << "false" << std::endl; 
	return 0;
}

3--最后一块石头的重量II

主要思路：

        类似于上题，可以转换为 0-1 背包问题；用一半的石头作为背包容量，另一半石头作为物品；

        背包装尽可能多的石头，最后两者相减相消即可得到最小的重量；

#include <iostream>
#include <vector>

class Solution {
public:
    int lastStoneWeightII(std::vector<int>& stones) {
		int sum = 0;
		for(int num : stones){
			sum += num;
		}
		int vec = sum / 2; // 一半作为容量
		std::vector<int> dp(vec+1, 0);
		// 初始化
		dp[0] = 0;
		// 遍历
		for(int i = 0; i < stones.size(); i++){
			for(int j = vec; j >= stones[i]; j--){
				dp[j] = std::max(dp[j], dp[j - stones[i]] + stones[i]); // 装尽可能多的石头
			}
		}
		return sum - dp[vec] - dp[vec]; // sum - dp[vec] 表示另一半的石头
    }
};

int main(int argc, char *argv[]) {
	// stones = [2,7,4,1,8,1]
	std::vector<int> test = {2, 7, 4, 1, 8, 1};
	Solution S1;
	int res = S1.lastStoneWeightII(test);
	std::cout << res << std::endl;
	return 0;
}

4--目标和

主要思路：
        转化为 0-1 背包问题，一部分数值连同 target 转化为背包容量，剩余一部分数值转化为物品，求解恰好装满背包容量的方法数；

        dp[j] 表示背包容量为 j 时，装满背包的方法数；

        状态转移方程：dp[j] += dp[j - nums[i]]，其实质是：当背包已经装了nums[i]时，剩余容量为 j - nums[i]，此时装满剩余容量的方法数为 dp[j - nums[i]]，遍历不同的 nums[i] 将方法数相加即可；

        是有点难理解。。。

#include <iostream>
#include <vector>

class Solution {
public:
    int findTargetSumWays(std::vector<int>& nums, int target) {
        int sum = 0;
        for(int num : nums) sum += num;
        if(sum < std::abs(target)) return 0; // 数组全部元素相加相减都不能构成target
        if((sum + target) % 2 == 1) return 0; // 不能二等分

        int bagsize = (sum + target) / 2;
        std::vector<int> dp(bagsize + 1, 0);
        dp[0] = 1;
        for(int i = 0; i < nums.size(); i++){ // 遍历物品
            for(int j = bagsize; j >= nums[i]; j--){ // 遍历背包容量
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[bagsize];
    }
};

int main(int argc, char *argv[]) {
    // nums = [1, 1, 1, 1, 1], target = 3
    std::vector<int> test = {1, 1, 1, 1, 1};
    int target = 3;
    Solution S1;
    int res = S1.findTargetSumWays(test, target);
    std::cout << res << std::endl;
	return 0;
}

5--一和零

主要思路：

        转化为 0-1 背包问题，背包容量为能装 m 个 0 和 n 个 1；

        dp[i][j] 表示0背包容量为i，1背包容量为j时，能装 strs 最大子集的长度；

        初始化 dp[0][0] = 0, dp[i][0] = 0; dp[0][j] = 0;

        状态转移方程：dp[i][j] = max(dp[i][j], dp[i-m1][j-n1] + 1)；m1 和 n1 分别表示字符串 0 和 1 的个数，dp[i-m1][j-n1] + 1 表示装上当前字符串后子集的长度；

#include <iostream>
#include <vector>
#include <string>

class Solution {
public:
    int findMaxForm(std::vector<std::string>& strs, int m, int n) {
        std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1, 0));
        for(int i = 0; i < strs.size(); i++){ // 遍历物品
            int m1 = 0, n1 = 0;
            for(char c : strs[i]){ // 统计当前字符串 0 和 1 字符的个数
                if(c == '0') m1++;
                else n1++;
            }
            // 遍历背包容量
            for(int j = m; j >= m1; j--){
                for(int k = n; k >= n1; k--){
                    dp[j][k] = std::max(dp[j][k], dp[j - m1][k - n1] + 1);
                }
            }
        }
        return dp[m][n];
    }
};

int main(int argc, char *argv[]) {
    // strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
    std::vector<std::string> test = {"10", "0001", "111001", "1", "0"};
    int m = 5, n = 3;
    Solution S1;
    int res = S1.findMaxForm(test, m, n);
    std::cout << res << std::endl;
	return 0;
}

6--完全背包问题

完全背包问题的特征：

        一共有 n 个物品，但每个物品可以任意选择多次；

一般解法：

        两层 for 循环从小到大遍历物品和背包容量；

        当先遍历物品，再遍历背包时，结果与物品顺序无关，一般用于组合问题；

        当先遍历背包，再遍历物品时，结果与物品顺序有关，一般用于排列问题；

7--零钱兑换II

主要思路：

        本题所有硬币可以任意取多次，因此是一个完全背包问题；

        对于上例，[2 2 1] 和[1 2 2] 是等价的，因此本题对应于组合问题，应先遍历物品，再遍历背包容量；

#include <iostream>
#include <vector>

class Solution {
public:
    int change(int amount, std::vector<int>& coins){
        std::vector<int> dp(amount + 1, 0); // dp[j] 表示背包容量为 j 时，凑成总金额为 j 的组合数
        dp[0] = 1; // 初始化
        for(int i = 0; i < coins.size(); i++){ // 遍历物品
            for(int j = coins[i]; j <= amount; j++){ // 遍历背包容量
                dp[j] += dp[j - coins[i]];
            }
        }
        return dp[amount];
    }
};

int main(int argc, char *argv[]) {
    // amount = 5, coins = [1, 2, 5]
    std::vector<int> test = {1, 2, 5};
    int amount = 5;
    Solution S1;
    int res = S1.change(amount, test);
    std::cout << res << std::endl;
	return 0;
}

8--组合总和IV

主要思路：

        本题所有整数可以任意取多次，因此是一个完全背包问题；

        对于上例，[2 2 1] 和[1 2 2] 不是等价的，因此本题对应于排列问题，应先遍历背包容量，再遍历物品；

#include <iostream>
#include <vector>

class Solution {
public:
    int combinationSum4(std::vector<int>& nums, int target) {
        std::vector<int> dp(target + 1, 0); // dp[j] 表示target为j时对应的组合个数
        dp[0] = 1; // 初始化
        for(int i = 0; i <= target; i++){
            for(int j = 0; j < nums.size(); j++){
                // C++测试用例有两个数相加超过int的数据，所以需要在if里加上dp[i] >= INT_MAX - dp[i - num]。
                if(i < nums[j] || dp[i] >= INT_MAX - dp[i - nums[j]]) continue; // 跳过背包容量小于物品容量的情况
                dp[i] += dp[i - nums[j]];
            }
        }
        return dp[target];
    }
};

int main(int argc, char *argv[]) {
    // nums = [1, 2, 3], target = 4
    std::vector<int> test = {1, 2, 3};
    int target = 4;
    Solution S1;
    int res = S1.combinationSum4(test, target);
    std::cout << res << std::endl;
	return 0;
}

9--零钱兑换

主要思路：

        本题所有硬币可以任意取多次，因此是一个完全背包问题；

#include <iostream>
#include <vector>
#include <limits.h>

class Solution {
public:
    int coinChange(std::vector<int>& coins, int amount) {
        std::vector<int> dp(amount + 1, INT_MAX); // dp[j] 表示凑成总金额为j时的最少硬币数
        dp[0] = 0;
        for(int i = 0; i < coins.size(); i++){ // 先遍历物品
            for(int j = coins[i]; j <= amount; j++){ // 再遍历背包容量
                if(dp[j - coins[i]] != INT_MAX){ // 如果dp[j - coins[i]]是初始值则跳过
                    // dp[j - coins[i]] != INT_MAX 确保dp[j - coins[i]] 确保组合中的硬币相加 == j - coins[i]，即恰好组合成金额
                    dp[j] = std::min(dp[j - coins[i]] + 1, dp[j]);
                }
            }
        }
        if (dp[amount] == INT_MAX) return -1;
        return dp[amount];
    }
};

int main(int argc, char *argv[]) {
    // coins = [1, 2, 5], amount = 11
    std::vector<int> test = {1, 2, 5};
    int amount = 11;
    Solution S1;
    int res = S1.coinChange(test, amount);
    std::cout << res << std::endl;
	return 0;
}

10--完全平方数

主要思路：

        完全平方数可以任意选取多次，因此可以转换为完全背包问题；

#include <iostream>
#include <vector>
#include <limits.h>

class Solution {
public:
    int numSquares(int n) {
        std::vector<int> dp(n + 1, INT_MAX); // dp[j] 表示构成整数 j 使用的最少完全平方数
        dp[0] = 0; // 初始化
        for(int i = 1; i*i <= n; i++){ // 遍历物品
            for(int j = i*i; j <= n; j++){ // 遍历背包
                dp[j] = std::min(dp[j], dp[j - i*i] + 1);
            }
        }
        return dp[n];
    }
};

int main(int argc, char *argv[]) {
    int n = 12;
    Solution S1;
    int res = S1.numSquares(n);
    std::cout << res << std::endl;
	return 0;
}

11--单词拆分

主要思路：

        本题中字符串列表的字符串可以任意选择多次，因此也可以转换为完全背包问题；

#include <iostream>
#include <vector>
#include <string>
#include <unordered_set>

class Solution {
public:
    bool wordBreak(std::string s, std::vector<std::string>& wordDict) {
        std::unordered_set<std::string> hash; // 先将字符串存到哈希表中，便于后面查询
        for(std::string word : wordDict){
            hash.insert(word);
        }
        std::vector<bool> dp(s.length() + 1, false); // dp[j] 表示目标字符串的前j个字符，其能由字符串列表中字符串构成
        dp[0] = true;
        for(int i = 1; i <= s.length(); i++){ // 遍历背包
            for(int j = 0; j <= i; j++){ // 遍历物品
                // dp[j] 可以由列表构成，同时s个字符构成的字符串，其剩余字符串也能由列表构成
                if(dp[j] == true && hash.find(s.substr(j, i-j)) != hash.end()){ // 这里将s.substr(j, i-j)认为是即将加入到背包的物品
                    dp[i] = true;
                    break; // 找到一种成功的组合就 break
                }
            }
        }
        return dp[s.length()];
    }
};

int main(int argc, char *argv[]) {
    // s = "leetcode", wordDict = ["leet", "code"]
    std::string str = "leetcode";
    std::vector<std::string> wordDict = {"leet", "code"};
    Solution S1;
    bool res = S1.wordBreak(str, wordDict);
    if(res) std::cout << "true" << std::endl;
    else std::cout << "false" << std::endl;
	return 0;
}

纳兰小熊
关注
专栏目录
数据结构看书笔记---lazyfennec整理精选
11-15
数据结构是计算机科学中的核心课程，它探讨了如何在计算机中高效地组织和管理数据，以...学习者通过这份精选笔记，可以系统性地掌握数据结构的核心概念，提高问题解决能力，并为后续的算法学习和软件开发打下坚实基础。
算法数据结构学习笔记-C语言.zip
最新发布
06-17
总之，《算法数据结构学习笔记-C语言》这份资料全面介绍了C语言实现的算法和数据结构，不仅有助于提高编程技能，也是提升问题解决能力的必备工具。通过深入学习和实践，你可以更好地理解和运用这些知识，从而在软件...
Leetcode动态规划——01背包问题
qq_41605114的博客
05-12 3508
https://blog.csdn.net/qq_34374664/article/details/52230368 分类参考 https://blog.csdn.net/yoer77/article/details/70943462?ops_request_misc=&request_id=&biz_id=102&utm_term=%E8%83%8C%E5%8C%85%E4%B9%9D%E8%AE%B2&utm_medium=distribute.pc_searc..
C++笔记之std::vector容器
Code_D张腾的博客
07-02 1092
vector实质是C++的一个类，与数组很相似，但是vector的优势是可以动态扩展，不需要考虑其内存大小。 1.vector的构造函数原型： vector<T>data;//使用模板类，默认构造函数 vector(data.begin(),data.end());//将data的【begin(),end())区间中的元素拷贝给本身，注意是数学中的前闭后开区间 vector(n,elem);//将n个elem元素拷贝给本身 vector(co...
【无标题】
m0_74233824的博客
07-21 779
要使用标准库中的类、函数或常量，需要在使用前加上"std::"前缀，以指定所属的命名空间。"语句，将整个"std"命名空间引入到当前的作用域中。总结起来，"std::"是C++标准库中的命名空间，其中包含了大量的类、函数和常量，用于实现各种常用的功能和操作。在main函数中调用modifyVector时，传入的是nums的引用，所以在函数执行完毕后，nums的内容被修改为{1, 2, 100, 4}。
C++中vector的使用
网络资源是无限的
05-26 1万+
C++中vector的使用
std::vector详解
qq_55914897的博客
09-18 1572
是 C++ 标准库中的一个动态数组容器类，提供了方便的操作函数和方法来处理动态大小的数组。它可以自动调整内存空间，并提供了丰富的成员函数来进行元素的插入、删除、访问和遍历等操作。是 C++ 标准库中的一个容器类，用于动态数组的管理。它提供了方便的操作函数和方法来处理动态大小的数组。定义和初始化： 可以使用以下方式定义和初始化一个。方法来获取当前存储的元素数量，提供了。还提供了许多其他常用的方法，如。插入和删除元素： 可以使用。方法在尾部插入元素，使用。删除指定位置的元素等。在指定位置插入元素，
数据结构看书笔记---精选lazyfennec整理
11-15
这份由lazyfennec精心整理的"数据结构看书笔记"涵盖了数据结构的主要内容，对于复习或学习这个主题非常有帮助。 一、线性结构 线性结构是最基础的数据结构，包括数组、链表和队列等。数组是一种静态存储结构，元素...
数据结构----清华殷人昆数据结构笔记（C＋＋版，ppt格式）
04-02
清华大学的殷人昆教授是数据结构领域的权威专家，他的数据结构笔记因其深入浅出的讲解而备受赞誉。这些PPT资料以C++语言为背景，深入剖析了数据结构的核心概念和算法。 1. **线性表与数组**：数组是最基本的数据...
数据结构笔记-严蔚敏
06-10
在严蔚敏的《数据结构》教学笔记中，你可以期待以下几个关键知识点的学习： 1. **线性结构**：包括数组、链表、栈和队列。数组是最基础的数据结构，支持随机访问但元素增删困难；链表解决了动态内存分配问题，但...
c++中vector的用法
hnxijie的博客
10-12 860
一、概述 vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector是一个容器，它能够存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，可以动态改变大小。 例如： int myHouse[100] ;// c语言风格 vector vecMyHouse(100);// 采用vector 当如上定义后，v
C++ vector＜int＞& nums 用法
haohandzhanshi的博客
05-28 1223
"vector<int>& nums"用法在函数参数传递和返回值中非常有用，它使得我们可以高效的操作向量 而不需要进行拷贝，提高程序性能。在使用时，需要注意引用的初始化以及引用对象的生存期问题。
C++里vector＜int＞& v 和vector＜int＞ v的区别
追梦人的博客
03-19 491
vector& v： 这表示 v 是一个指向 vector 对象的引用。引用是变量的别名，因此 v 和另一个。vector 对象可以互相交换数据，对 v 的操作实际上就是对原始 vector 对象的操作。vector v： 这表示 v 是一个 vector 类型的对象。是一个独立的对象，它有自己的存储空间，独立于其他 vector 对象。函数里的参数（vector& v_ref有无&）进行验证。
std::vector的几种遍历方式比较
热门推荐
ls306196689的专栏
06-29 8万+
std::vector是我在标准库中实用最pi
std::vector 的使用陷阱
tianyexing2008的博客
08-16 1769
std::vector 在工作当中的使用频率比较高，因为它简单易用，类似数组，但又比数组智能得多，它能动态调整内存以容纳足够多的数据。这里就有一个不易察觉的陷阱，假如是数组我们是可以通过 array[n] = xx (这里n是有效范围的) 进行赋值，但在 std::vector 里，这个是获取元素用的，它返回的是元素的引用。定义 vector 后直接用 [] 进行赋值是非法的，因为此时 vector 内部的指针是空的，访问空指针是会引起 segmentation fault。.........
c++中vector的用法详解
Winterto1990的博客
08-16 3000
vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的.      用法:           1.文件包含:                 首先在程序开头处加上#include以包含所需要的类文件vector           还有一定要加上using name
C++入门笔记之std::vector容器详解
hakljz的博客
07-06 2208
这篇文章主要给大家介绍了关于C++之std::vector容器的相关资料,vector,一种随机访问的数组类型,它提供了对数组元素的快速、随机访问,以及在序列尾部快速、随机的插入和删除操作,需要的朋友可以参考下 目录 前言 1. vector的构造函数原型： 2. vector的赋值函数原型： 3. vector的容量和大小函数原型： 4. vector的插入和删除函数原型： 5. vector的存取操作函数原型： 6. vector的呼唤容器函数原型： 总结 前言 vector实质
std::vector用法
codemanrock
08-06 2万+
vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。 为了可以使用vector，必须在你的头文件中包含下面的代码： #include vector属于std命名域的，因此需要通过命名限
《数据结构》考研复习精华笔记
7. **动态规划**：在解决数据结构问题中的应用，如背包问题、最短路径问题等。 8. **递归与回溯**：递归思想的理解和应用，如递归解法在树和图问题中的应用，回溯法解决组合问题。 9. **数据结构设计与分析**：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值