leetcode刷题笔记

牛+马=我

已于 2023-10-22 20:34:39 修改

阅读量60

点赞数

文章标签： c++ leetcode

于 2023-08-29 22:21:30 首次发布

本文链接：https://blog.csdn.net/qq_57780419/article/details/132571190

版权

C++ leetcode notes

vector<int> vec;
int value = 42;
vec.push_back(value); // 添加 value 的副本到 vec

vector<int*> vec;
int value = 42;
int* ptr = &value;
vec.push_back(ptr); // 添加指针 ptr 的副本到 vec，但ptr和副本指向的空间是一致的

vector<string> vec;
string str = "Hello";
vec.push_back(move(str)); // 移动 str 到 vec，而不是复制c++11新特性，加上move就是把str直接移动到vec中，而不是复制，提高效率

所以可以看到，vector中push_back基本都是副本，加上move就是移动，不是副本。

C++ leetcode notes

c++定义数组初始化可以直接这样写：

int used[201] = {0};//201个元素初始化都是0

C++ leetcode notes

数组，set，map都可以做哈希表，而且数组干的活，map和set都能干，但如果数值范围小的话能用数组尽量用数组

C++ leetcode notes

回溯法模板：

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

C++ leetcode notes

回溯法注意有树枝不重复和树层不重复
树层不重复的方法：

方法1.当nums可以sort排序的时候，用方法1，因为使用used数组必须先排序，并且方法1的时间复杂度和空间复杂度都小
//定义一个nums的used的数组，数组表示nums中哪些元素使用了，使用了在used中对于位置为true，否则为false
if (i > startIndex && nums[i] == nums[i-1] && used[i-1] == false) continue; or break;
// nums[i] == nums[i-1] && used[i-1] == false  表示数层重复，说明同一树层nums[i - 1]使用过
// nums[i] == nums[i-1] && used[i-1] == true   表示树枝重复，说明同一树枝nums[i - 1]使用过
方法2.当nums数组不可以sort排序的时候，用方法2，较法1运算时间更长，需要空间更多，但是nums可以不排序
unordered_set<int> uset;
if (uset.find(nums[i]) != uset.end()) continue;
//uset.find(nums[i]) != uset.end() 表示本层找到了这个元素。那么就是树层重复，直接continue

C++ leetcode notes

在回溯算法中，比如nums=[1,2,3]。
组合问题中[1,2]和[2,1]是相同的。所以必须从startIndex开始，即选了1之后，下一个要选的是从startIndex=2开始。
而排列问题中，[1,2]和[2,1]是不同的，所以选过2之后，除了2以外，1和3都要选，所以下一个选的要从i=0开始，但是需要一个used数组标明2已经选了，接下来选其他的就行，即从i=0开始，但是i=1不能选。

C++ leetcode notes

C++11中引入了一种称为"range-based for loop"的新语法，提供了一种简洁的方式来遍历容器（如数组、向量、列表等）的元素。
语法如下：

for (element_declaration : range_expression) {
    // 循环体
}

range_expression是要遍历的容器，element_declaration用于接收容器中每个元素的，在每次循环中，range_expression中的元素依次赋值给element_declaration。
例子：

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    for (int num : numbers) {
        std::cout << num << " ";
    }

    return 0;
}

//输出为1 2 3 4 5

C++ leetcode notes

在ASCII码中，字符’0’-'9’是连续的，‘9’-'10’是不连续的，‘10’是字符’1’和’0’的组合

C++ leetcode notes

一个int型变量a，需要处理这个整数的每一位上的数字，换成string更方便：string aStr = to_string(a)，这样就不用while循环取出每一位数字进行操作了，处理完之后再把aStr换成int：a = stoi(aStr)

C++ leetcode notes

01背包：

void test_1_wei_bag_problem() {
    vector<int> weight = {1, 3, 4};//物品的重量
    vector<int> value = {15, 20, 30};//物品的价值
    int bagWeight = 4;//背包的最大重量

    // 初始化
    vector<int> dp(bagWeight + 1, 0);
    for(int i = 0; i < weight.size(); i++) { // 遍历物品
        for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bagWeight] << endl;
}

int main() {
    test_1_wei_bag_problem();
}

可以看到01背包是外层变量物品，内层变量背包容量，并且不能调换顺序。在变量背包容量的时候，为了对物品只取一次，需要从后向前遍历。

C++ leetcode notes

完全背包：

// 先遍历物品，在遍历背包
void test_CompletePack() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagWeight = 4;
    vector<int> dp(bagWeight + 1, 0);
    for(int i = 0; i < weight.size(); i++) { // 遍历物品
        for(int j = weight[i]; j <= bagWeight; j++) { // 遍历背包容量
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bagWeight] << endl;
}
int main() {
    test_CompletePack();
}

// 先遍历背包，再遍历物品
void test_CompletePack() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagWeight = 4;

    vector<int> dp(bagWeight + 1, 0);

    for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
        for(int i = 0; i < weight.size(); i++) { // 遍历物品
            if (j - weight[i] >= 0) dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bagWeight] << endl;
}
int main() {
    test_CompletePack();
}

可以先遍历物品，再遍历背包容量。也可以先遍历背包容量，再遍历物品。
并且遍历背包容量的时候由于是完全背包，物品数量无限，所以直接从前向后遍历。

C++ leetcode notes

在求组合数的时候，递推公式是dp[j] += dp[j - weight[i]];
对于完全背包

for (int i = 0; i < coins.size(); i++) { // 遍历物品
    for (int j = coins[i]; j <= amount; j++) { // 遍历背包容量
        dp[j] += dp[j - coins[i]];
    }
}

遍历的是组合数

for (int j = 0; j <= amount; j++) { // 遍历背包容量
    for (int i = 0; i < coins.size(); i++) { // 遍历物品
        if (j - coins[i] >= 0) dp[j] += dp[j - coins[i]];
    }
}

遍历的是排列数
总结：
如果求组合数就是外层for循环遍历物品，内层for遍历背包。

如果求排列数就是外层for遍历背包，内层for循环遍历物品。

C++ leetcode notes

纯 0 - 1 背包 (opens new window) 是求给定背包容量装满背包的最大价值是多少。
递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

leetcode 416. 分割等和子集 (opens new window) 是求给定背包容量，能不能装满这个背包。
那么weight和value认为都是nums中的数字，递推公式：dp[j] = max(dp[j], dp[j - nums[i]] +nums[i]),判断能否装满：if (dp[target] == target)...

leetcode1049. 最后一块石头的重量 II (opens new window) 是求给定背包容量，尽可能装，最多能装多少
递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])，尽可能的装，最后返回return dp[target];

leetcode 494. 目标和 (opens new window) 是求给定背包容量，装满背包有多少种方法。
递推公式：dp[j] += dp[j - nums[i]]，即背包容量为j的方法数就是没有加物品i时的方法数 + 加上物品i的方法数（即背包容量为 j - nums[i] 的方法数），需要注意的是初始化dp[j] = 0并且dp[0] = 1，因为如果为dp[0] = 0，推出后面的所有的都是0

leetcode 474.一和零是求给定背包容量，装满背包最多有多少个物品。
递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + 1)，即背包容量为j时装的最多的物品数是没有加物品i时的物品数与加上物品i的物品数（即背包容量为 j - weight[i] 时的物品数 + 1，这个1指的是物品i）的最大值，需要注意的是初始化dp[j] = 0
如果是求装满背包的最少物品数，则递推公式是dp[j] = min(dp[j], dp[j - weight[i]] + 1)，但是此时初始化dp[j] = INT_MAX，并且dp[0] = 0，因为需要进行加法运算并且比大小，dp[0]需要为0，否则是INT_MAX的话无法+1，并且 dp[0] = 0 也有实际含义：背包容量为0，装满需要的物品数最少确实是0