wy的leetcode刷题记录_Day43

最新推荐文章于 2024-07-25 11:15:54 发布
最新推荐文章于 2024-07-25 11:15:54 发布
阅读量211 收藏
点赞数
分类专栏： C语言 Leetcode刷题记录 文章标签： leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54015435/article/details/127860838
版权

wy的leetcode刷题记录_Day40

声明

本文章的所有题目信息都来源于leetcode
如有侵权请联系我删掉!
时间：2022-11-15

前言

今天时间比较多而且题目比较简单，应该能写三四道题。

目录

1710. 卡车上的最大单元数

今天的每日一题是：1710. 卡车上的最大单元数

题目介绍

请你将一些箱子装在 一辆卡车 上。给你一个二维数组 boxTypes ，其中 boxTypes[i] = [numberOfBoxesi, numberOfUnitsPerBoxi] ：

  • numberOfBoxesi 是类型 i 的箱子的数量。
  • numberOfUnitsPerBoxi 是类型 i 每个箱子可以装载的单元数量。

整数 truckSize 表示卡车上可以装载 箱子 的 最大数量 。只要箱子数量不超过 truckSize ，你就可以选择任意箱子装到卡车上。

返回卡车可以装载 单元 的 最大 总数。

示例 1：
输入：boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4
输出：8
解释：箱子的情况如下：

  • 1 个第一类的箱子，里面含 3 个单元。
  • 2 个第二类的箱子，每个里面含 2 个单元。
  • 3 个第三类的箱子，每个里面含 1 个单元。 可以选择第一类和第二类的所有箱子，以及第三类的一个箱子。 单元总数 = (1 * 3) + (2 * 2) + (1 * 1) = 8

示例 2：
输入：boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10
输出：91

思路

方法一：一个简单的贪心思路：先将boxTypes按照其numberOfUnitsPerBoxi的大小排列顺序，然后根据其数量装箱，到最后只有俩种情况，就是该类型的箱子数量>剩下所需的箱子数量，这样的话只需把剩下所需的箱子数量的该类型的箱子放入即可；还有就是该类型的箱子数量<剩下所需的箱子数量，这样就需要将该类型的箱子全部放入后，继续放入下一个类型的箱子。
方法二：由于本题目的数据量较小，所以可以创建一个空的数组truck，通过遍历boxTypes，填充这个数组，下标为其箱子能装载的单元数量，值为箱子的数量。最后从后往前再遍历这个truck，也就是从最大的箱子能装载的单元数量开始放入。（这样的话相比于方法一的排序时间复杂度要低一些的）

代码

贪心：

class Solution {
public:
    int maximumUnits(vector<vector<int>>& boxTypes, int truckSize) {
        //
        int ans=0;
        if(boxTypes.empty())
            return ans;
        sort(boxTypes.begin(), boxTypes.end(), [](const vector<int> &a, const vector<int> &b) {
            return a[1] > b[1];
        });
        int j=0;
        for(auto boxType:boxTypes)
        {
            int box_num=boxType[0];
            int box_val=boxType[1];
            
            if(box_num<=truckSize)
            {
                ans+=box_num*box_val;
                truckSize-=box_num;
            }

            else
            {
                ans+=truckSize*box_val;
                break;
            }


        }
        return ans;
    }
};

计数排序：

class Solution {
public:
    int maximumUnits(vector<vector<int>>& boxTypes, int truckSize) {
        int truck[1001] = {0};
        for (auto& boxType : boxTypes) {
            int numberOfBoxesi  = boxType[0], numberOfUnitsPerBoxi  = boxType[1];
            truck[numberOfUnitsPerBoxi ] += numberOfBoxesi ;
        }
        int ans = 0;
        for (int numberOfUnitsPerBoxi = 1000; numberOfUnitsPerBoxi > 0 && truckSize > 0; --numberOfUnitsPerBoxi) {
            int numberOfBoxesi = truck[numberOfUnitsPerBoxi];
            if (numberOfBoxesi) {
                ans += numberOfUnitsPerBoxi * min(truckSize, numberOfBoxesi);
                truckSize -= numberOfBoxesi;
            }
        }
        return ans;
    }
};

收获

简单的模拟贪心思路，以及再数据量小的时候可以稍微牺牲一下空间性能来提升时间性能

513. 找树左下角的值

513. 找树左下角的值

题目介绍

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。

假设二叉树中至少有一个节点。

示例 1:
在这里插入图片描述
输入: root = [2,1,3]
输出: 1

示例 2:
在这里插入图片描述
输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7

思路

方法一：DFS：前序遍历，维护一个最大深度和最大深度左节点值就可以
方法二：BFS：记录层次，遍历到最深层次后第一个值就是树左下角的值

代码

DFS:

/**
 * 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 maxLen = INT_MIN;
        int maxleftValue;
        void traversal(TreeNode* root, int leftLen) 
        {
            if (root->left == NULL && root->right == NULL) 
            {
                if (leftLen > maxLen) 
                {
                    maxLen = leftLen;
                    maxleftValue = root->val;
                }
                return;
            }
            if (root->left)
             {
                traversal(root->left, leftLen + 1); // 隐藏着回溯
            }
            if (root->right) 
            {
                traversal(root->right, leftLen + 1); // 隐藏着回溯
            }
            return;
            }

        int findBottomLeftValue(TreeNode* root) {
            traversal(root, 0);
            return maxleftValue;
    }
};

BFS:

/**
 * 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 findBottomLeftValue(TreeNode* root) {
        int ans=0;
        queue<TreeNode*> qu;
        if(!root)
            return ans;
        qu.push(root);
        while(!qu.empty())
        {
            int n=qu.size();
            for(int i=0;i<n;i++)
            {
                TreeNode* node=qu.front();
                qu.pop();
                if(i==0)
                    ans=node->val;
                if(node->left)
                    qu.push(node->left);
                if(node->right)
                    qu.push(node->right);
            }
        }
        return ans;
    }

};

收获

熟练了BFS和DFS对各种要求的应用

112. 路径总和

112. 路径总和

题目介绍

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。

示例 1：
在这里插入图片描述
输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：
在这里插入图片描述

输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：

  • (1 -->2): 和为 3
  • (1 --> 3): 和为 4

不存在 sum = 5 的根节点到叶子节点的路径。

思路

本题方法太多了，我这里只写了一个用栈来模拟递归的方法。

代码

/**
 * 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 hasPathSum(TreeNode* root, int targetSum) {
        if(!root)
            return false;
        stack<pair<TreeNode *,int>> path;
        path.push({root,root->val});
        
        while(!path.empty())
        {
            pair<TreeNode *,int> node=path.top();
            path.pop();
            if (!node.first->left && !node.first->right && targetSum == node.second) 
                return true;
            if (node.first->left) {
                path.push(pair<TreeNode*, int>(node.first->left, node.second +
                node.first->left->val));
            }
            // 右节点，压进去⼀个节点的时候，将该节点的路径数值也记录下来
            if (node.first->right) {
                path.push(pair<TreeNode*, int>(node.first->right, node.second +
                node.first->right->val));
            }
        }
        return false;
        }
    
};

收获

对调用系统栈的方式更加了解。

113. 路径总和 II

113. 路径总和 II

题目介绍

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

叶子节点 是指没有子节点的节点。

示例 1：
在这里插入图片描述
输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

示例 2：
在这里插入图片描述
输入：root = [1,2,3], targetSum = 5
输出：[]

思路

BFS：这一题使用BFS还是有一些麻烦的，因为当你遍历到符合要求的叶子节点时，你需要去找到他的链路，就是根据他的父节点依次向上寻找，于是我额外使用了一个hashmap来记录每个节点的父节点。
DFS：用一个临时path来记录当前遍历的路径，并且在不符合条件回退时path也要进行回溯。

代码

BFS：

/**
 * 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<vector<int>> ans;
    unordered_map<TreeNode* ,TreeNode*> parent;
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {

        if(!root)
            return ans;
        queue<pair<TreeNode*,int>> qu;
        qu.push({root,root->val});
        while(!qu.empty())
        {
            pair<TreeNode*,int> node=qu.front();
            qu.pop();
            if(!node.first->left&&!node.first->right&&node.second==targetSum)
                getPath(node.first);
            else
           {
                if(node.first->left)
                {
                    parent[node.first->left]=node.first;
                    qu.push({node.first->left,node.second+node.first->left->val});
                }

                if(node.first->right)
                {
                    parent[node.first->right]=node.first;
                    qu.push({node.first->right,node.second+node.first->right->val});
                }            
            }
        }
        return ans;
    }

    void getPath(TreeNode* node) {
        vector<int> tmp;
        while (node != nullptr) {
            tmp.emplace_back(node->val);
            node = parent[node];
        }
        reverse(tmp.begin(), tmp.end());
        ans.emplace_back(tmp);
    }
};

DFS：

class Solution {
public:
    vector<vector<int>> ret;
    vector<int> path;

    void dfs(TreeNode* root, int targetSum) {
        if (root == nullptr) {
            return;
        }
        path.emplace_back(root->val);
        targetSum -= root->val;
        if (root->left == nullptr && root->right == nullptr && targetSum == 0) {
            ret.emplace_back(path);
        }
        dfs(root->left, targetSum);
        dfs(root->right, targetSum);
        path.pop_back();
    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        dfs(root, targetSum);
        return ret;
    }
};

收获

其实这俩道题已经有较明显的回溯意思了，稍微掌握了一些。

wy-1226
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
实现一个计算输入的两数的和与差的简单函数。
m0_54015435的博客
03-23 1万+
实现一个计算输入的两数的和与差的简单函数。 首先 我们知道一般从子函数只能向主函数中返回一个值，可是本题却要求我们返回和与差，这样我们就无法通过返回值来进行完成，于是我相信很多初学者都会犯如下错误：在子函数中通过值传递的方式计算出加减的结果，让后在主函数中输出，我们先来看一下错误实例: 错误示例 #include<stdio.h> void sum_diff(float op1, float op2, float psum, float pdiff); int main() { float
educoder第2关：栈的应用 - 计算后缀表达式
m0_54015435的博客
04-26 1374
double ComputePostfix(char* s) { // 请在此添加代码，补全函数ComputePostfix，计算后缀表达式 /********** Begin *********/ int i = 0;//数组下标 T num1 = 0; T num2 = 0; T num = 0; LinkStack* so = LS_Create(); // 创建运算符栈 while (s[i]) { if (s[i] >= '0'&&s[i]
7-11 字符串排序
m0_54015435的博客
05-10 1127
7-11 字符串排序 #include<stdio.h> #include<string.h> #define n 5 int main() { char str[5][81];//多一位用于存放'\0' int i; int N=n; for(i=0;i<5;i++)//输入五个字符串 { scanf("%s",str[i]); } //sort int
wy的leetcode刷题记录_Day33
m0_54015435的博客
11-04 857
leetcode
wy的leetcode刷题记录_Day34
m0_54015435的博客
11-05 747
leetcode
wy的leetcode刷题记录_Day37
m0_54015435的博客
11-08 678
leetocode
7-1 数组元素循环右移问题
m0_54015435的博客
05-10 642
PTA 7-1 数组元素循环右移问题 #include<stdio.h> #define MAXN 200 int main() { int a[200]={0};//要求空间的俩倍 int n=0;//数组中数的实际数量 int m=0;//循环往右的位次 int i;//循环变量 int j;//循环变量 scanf("%d",&n);//输入n scanf("%d",&m);//输入m for(i=0
练习5-3 数字金字塔 (15 分)
m0_54015435的博客
04-28 575
练习5-3 数字金字塔 (15 分) 本题要求实现函数输出n行数字金字塔。 函数接口定义： void pyramid( int n ); 其中n是用户传入的参数，为[1, 9]的正整数。要求函数按照如样例所示的格式打印出n行数字金字塔。注 意每个数字后面跟一个空格。 裁判测试程序样例： #include <stdio.h> void pyramid( int n ); int main() { int n; scanf("%d", &n); pyr
wy的leetcode刷题记录_Day56
m0_54015435的博客
12-04 544
2022-11-30 每日一题：灵活使用STL+二叉树的后序遍历
wy的leetcode刷题记录_Day46
m0_54015435的博客
11-21 451
leetcode
wy的leetcode刷题记录_Day51
m0_54015435的博客
11-28 424
力扣每日一题 搜索二叉树专题
wy的leetcode刷题记录_Day60
m0_54015435的博客
12-21 423
leetcode
wy的leetcode刷题记录_Day59
m0_54015435的博客
12-21 412
leetcode
wy的leetcode刷题记录_Day41
m0_54015435的博客
11-13 400
leetcode
wy的leetcode刷题记录_Day40
m0_54015435的博客
11-12 394
leetcode
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 901
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
C++ | Leetcode C++题解之第283题移动零
Ddddddd_158的博客
07-25 375
C++ | Leetcode C++题解之第283题移动零
LeetCode707 设计链表
最新发布
daishabby2486的博客
07-25 655
LeetCode707 设计链表的解题记录。
Leetcode—769. 最多能完成排序的块【中等】
Atticus的博客
07-25 388
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
"详细代码解析：Leetcode刷题记录
在本文中，我将分享我的leetcode刷题记录，包括我在解决每个问题时所使用的代码和思路讲解。这份记录非常详细，旨在帮助其他人更好地理解leetcode题目的解法和编程技巧。 21、TWO SUM 这道题的关键在于要找到数组中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

wy-1226

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

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

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

打赏作者

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

抵扣说明：

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

余额充值