代码随想录算法训练营Day44 | 完全背包，518. 零钱兑换 II，377. 组合总和 Ⅳ | Day 15 复习

最新推荐文章于 2024-09-12 19:02:20 发布
最新推荐文章于 2024-09-12 19:02:20 发布
阅读量116 收藏
点赞数
分类专栏： 代码随想录刷题训练营 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44687153/article/details/132554406
版权

完全背包

文章链接  |  视频链接

完全背包：每个物品可以使用无数次

01背包核心代码：倒数遍历为了每个物品只使用一次！

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]);
    }
}

变更为正序遍历则是完全背包：

// 先遍历物品，再遍历背包
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]);

    }
}

完全背包问题的两层for可以颠倒

518. 零钱兑换 II

文章链接  |  题目链接  |  视频链接

C++解法

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<int> dp (amount+1, 0);
        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];
    }
};

Python解法

class Solution:
    def change(self, amount: int, coins: List[int]) -> int:
        dp = [0] * (amount+1)
        dp[0] = 1
        for i in range(len(coins)):
            for j in range(coins[i], amount+1):
                dp[j] += dp[j-coins[i]]
        return dp[amount]

377. 组合总和 Ⅳ 

文章链接  |  题目链接  |  视频链接

C++解法

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<int> dp (target+1, 0);
        dp[0] = 1;
        for (int i = 0; i <= target; i++){
            for (int j = 0; j < nums.size(); j++){
                if (i - nums[j] >= 0 && dp[i] < INT_MAX - dp[i - nums[j]]) {
                    dp[i] += dp[i - nums[j]];
                }
            }
        }
        return dp[target];
    }
};

Python解法

class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        dp = [0] * (target+1)
        dp[0] = 1
        for i in range(1, target+1):
            for j in nums:
                if i >= j:
                    dp[i] += dp[i - j]
        return dp[-1]

Day 15 复习

102.二叉树的层序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void BFS(TreeNode* curr, vector<vector<int>>& result, int depth){
        if (curr == nullptr){
            return;
        }
        if (result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(curr->val);
        BFS(curr->left, result, depth+1);
        BFS(curr->right, result, depth+1);
    }
    
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        BFS(root, result, 0);
        return result;
    }
};

107.二叉树的层次遍历II

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void BSF(TreeNode* curr, vector<vector<int>>& result, int depth){
        if (curr == nullptr) return;
        if (result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(curr->val);
        BSF(curr->left, result, depth+1);
        BSF(curr->right, result, depth+1);
    }

    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        BSF(root, result, 0);
        reverse(result.begin(), result.end());
        return result;
    }
};

199.二叉树的右视图

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void BSF(TreeNode* curr, vector<int>& result, int depth){
        if (curr == nullptr) return;
        if (result.size() == depth) result.push_back(curr->val);
        BSF(curr->right, result, depth+1);
        BSF(curr->left, result, depth+1);
    }

    vector<int> rightSideView(TreeNode* root) {
        vector<int> result;
        BSF(root, result, 0);
        return result;
    }
};

637.二叉树的层平均值

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<double> result;
        
        while (!que.empty()){
            int size = que.size();
            double sum = 0;
            TreeNode* node;
            for (int i = 0; i < size; i++){
                node = que.front();
                sum += node->val;
                que.pop();
                if (node->left){
                    que.push(node->left);
                }
                if (node->right){
                    que.push(node->right);
                }
            }
            result.push_back(sum / size);
        }
        return result;
    }
};

429.N叉树的层序遍历

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    void BSF(Node* curr, vector<vector<int>>& result, int depth){
        if (curr == nullptr) return;
        if (result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(curr->val);
        for (int i = 0; i < curr->children.size(); i++){
            if (curr->children[i]){
                BSF(curr->children[i], result, depth+1);
            }
        }
    }

    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> result;
        BSF(root, result, 0);
        return result;
    }
};

515.在每个树行中找最大值

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<int> result;
        
        while (!que.empty()){
            int size = que.size();
            int max = INT_MIN;
            TreeNode* node;
            for (int i = 0; i < size; i++){
                node = que.front();
                max = max < node->val ? node->val : max;
                que.pop();
                if (node->left){
                    que.push(node->left);
                }
                if (node->right){
                    que.push(node->right);
                }
            }
            result.push_back(max);
        }
        return result;
    }
};

116.填充每个节点的下一个右侧节点指针

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);        
        while (!que.empty()){
            int size = que.size();
            for (int i = 0; i < size; i++){
                Node* node = que.front();
                que.pop();
                if (i != size-1){
                    node->next = que.front();
                }
                if (node->left){
                    que.push(node->left);
                }
                if (node->right){
                    que.push(node->right);
                }
            }
        }
        return root;
    }
};

117.填充每个节点的下一个右侧节点指针II

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);        
        while (!que.empty()){
            int size = que.size();
            for (int i = 0; i < size; i++){
                Node* node = que.front();
                que.pop();
                if (i != size-1){
                    node->next = que.front();
                }
                if (node->left){
                    que.push(node->left);
                }
                if (node->right){
                    que.push(node->right);
                }
            }
        }
        return root;
    }
};

104.二叉树的最大深度

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int getDepth(TreeNode* curr){
        if (curr == NULL){
            return 0;
        }
        int left_depth = getDepth(curr->left);
        int right_depth = getDepth(curr->right);
        return 1 + max(left_depth, right_depth);
    }

    int maxDepth(TreeNode* root) {
        return getDepth(root);
    }
};

111.二叉树的最小深度

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
   int getHeight(TreeNode* curr){
        if (curr == NULL) return 0;
        int left_height = getHeight(curr->left);
        int right_height = getHeight(curr->right);
        if (curr->left == NULL && curr->right){
            return 1 + right_height;
        } else if (curr->right == NULL && curr->left){
            return 1 + left_height;
        } else {
            return 1 + min(left_height, right_height);
        }
    }

    int minDepth(TreeNode* root) {
        return getHeight(root);
    }
};

226.翻转二叉树 （优先掌握递归）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);        
        while (!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            swap(node->left, node->right);
            if (node->left){
                st.push(node->left);
            }
            if (node->right){
                st.push(node->right);
            }
        }
        return root;
    }
};

101. 对称二叉树 （优先掌握递归）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right){
        if (left == NULL && right != NULL) return false;
        else if (left != NULL && right == NULL) return false;
        else if (left == NULL && right == NULL) return true;
        else if (left->val != right->val) return false;
        bool outside = compare(left->left, right->right);
        bool inside = compare(left->right, right->left);
        return inside && outside;
    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        return compare(root->left, root->right);
    }
};


 

zxqbsa
关注
专栏目录
代码随想录算法训练营第四十二天 | 01背包问题
weixin_42252688的博客
03-14 276
01背包问题
代码随想录算法训练营第42天 | 01背包问题理论基础 + 416.分割等和子集
weixin_42286468的博客
06-20 504
代码随想录算法训练营 打卡博文 第42天
代码随想录算法训练营Day43 | 完全背包 518. 零钱兑换 II 377. 组合总和 Ⅳ
qq_24817679的博客
05-19 211
注意 ：1.2.3.4.
代码随想录算法训练营day44 | 完全背包、518. 零钱兑换 II、377. 组合总和 Ⅳ
sunflowers11的博客
02-28 528
第i件物品的重量是weight[i]，得到的价值是value[i]。因为dp[j] 是根据 下标j之前所对应的dp[j]计算出来的。只要保证下标j之前的dp[j]都是经过计算的就可以了。外层for循环遍历物品（钱币），内层for遍历背包（金钱总额）的情况，这种遍历顺序中dp[j]里计算的是组合数(无序)！01背包中二维dp数组的两个for遍历的先后循序是可以颠倒了，一维dp数组的两个for循环先后循序一定是先遍历物品，再遍历背包容量。2. 确定递推公式：dp[j] += dp[j - coins[i]]
代码随想录算法训练营day44｜完全背包，518. 零钱兑换II，377. 组合总和 Ⅳ
weixin_52121600的博客
12-08 251
动态规划day6
代码随想录算法训练营Day7 | 344.反转字符串，541. 反转字符串II，卡码网：54.替换数字
little__penguin的博客
06-13 825
代码随想录算法训练营Day6 | 454.四数相加II，383. 赎金信，15. 三数之和，18. 四数之和，总结
little__penguin的博客
06-12 328
代码随想录算法训练营day 60 |84.柱状图中最大的矩形
wuhuqifei123的博客
02-08 336
代码随想录算法训练day60
代码随想录算法训练营Day3 | 链表理论基础，203.移除链表元素，707.设计链表，206.反转链表
little__penguin的博客
06-08 379
代码随想录算法训练营Day22 | 491.递增子序列，46.全排列，47.全排列 II ，332. 重新安排行程，51. N皇后，37. 解数独，总结
little__penguin的博客
07-07 433
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
最新发布
qq_61936886的博客
09-12 485
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 282
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1169
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 309
试除法求约数、约数个数、约数之和、最大公约数
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 466
64. 最小路径和。
算法练习题24——查找杨辉三角中的组合数
hello77的blogggg 祝你得偿所愿
09-12 573
逐项递推法适合处理较小的数据量，计算较为直观，但当杨辉三角行数较大时，效率较低。 二分查找法利用组合数的单调性，显著提高查找效率，适合处理较大的数据范围。这两种解法在不同场景下都可以使用，二分查找法尤其适合大规模数据下的查找问题。
算法练习题22——解码
hello77的blogggg 祝你得偿所愿
09-11 382
小明有一串很长的英文字母，其中可能包含大写和小写字母。在这串字母中，有很多字母是连续且重复的。为了压缩这串字母的表达形式，小明决定将连续相同的字母用“字母 + 出现次数”的形式表示。
二分系列(二分查找)9/12
2301_78191305的博客
09-12 962
排序数组->使用二分。第一个位置:>=；第二个位置:=(target+1)-1；所以直接写一个>=的函数。
18068 选择排序
huang1xiao1sheng的博客
09-11 426
输入10个整数，编写一个实现对数组进行选择排序的函数 #include int sort(int a[], int n) { int i,j,k,tmp; for(i=0;i
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
该代码使用了递归法的前序遍历，对于每一个节点，交换其左右子节点，然后递归地对其左右子树进行翻转。 引用中给出了一个实现二叉树的层序遍历的代码示例。该代码使用了BFS的思想，借助队列来实现层序遍历。每一层...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值