wy的leetcode刷题记录_Day43

最新推荐文章于 2024-03-18 11:24:14 发布
最新推荐文章于 2024-03-18 11:24:14 发布
阅读量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
    评论
专栏目录
wy的leetcode刷题记录_Day59
m0_54015435的博客
12-21 409
leetcode
leetcode刷题记录
渐近自由
10-13 640
1. Two Sum  （2016.10.11） 题意：给一组数，寻找其中和为target的两个数，返回他们的index。 解法：暴力可过，map可过（技巧是边维护边遍历，这样可以剔除相同数不同index的情况），set可过（也是边维护边遍历）。 2. Add Two Numbers  （2016.10.12） 题意：将两个用链表反向存储的数做加法，求结果。e.g   l1:
wy的leetcode刷题记录_Day79
m0_54015435的博客
03-01 846
wy的leetcode刷题记录_Day79声明前言2369. 检查数组是否存在有效划分题目介绍思路代码收获61. 旋转链表题目介绍思路代码收获82. 删除排序链表中的重复元素 II题目介绍思路代码收获给你一个下标从 0 开始的整数数组 nums ，你必须将数组划分为一个或多个 连续 子数组。1.子数组 恰 由 2 个相等元素组成，例如，子数组 [2,2]。2.子数组 恰 由 3 个相等元素组成，例如，子数组 [4,4,4]。3.子数组 恰 由 3 个连续递增元素组成，并且相邻元素之间的差值为 1。
wy的leetcode刷题记录_Day90
最新发布
m0_54015435的博客
03-18 902
wy的leetcode刷题记录_Day89声明前言303. 区域和检索 - 数组不可变题目介绍思路代码收获230. 二叉搜索树中第K小的元素题目介绍思路代码收获199. 二叉树的右视图题目介绍思路代码收获114. 二叉树展开为链表题目介绍思路代码收获105. 从前序与中序遍历序列构造二叉树题目介绍思路代码收获计算索引 left 和 right （包含 left 和 right）之间的 nums 元素的 和 ，其中 left
wy的leetcode刷题记录_Day71
m0_54015435的博客
01-04 860
wy的leetcode刷题记录_Day71声明前言2487. 从链表中移除节点题目介绍思路代码收获509. 斐波那契数题目介绍思路代码收获给你一个链表的头节点 head。移除每个右侧有一个更大数值的节点。返回修改后链表的头节点 head。示例 1：> 输入：head = [5,2,13,3,8]输出：[13,8]解释：需要移除的节点是 5 ，2 和 3。> - 节点 13 在节点 5 右侧。节点 13 在节点 2 右侧。节点 8 在节点 3 右侧。
LeetCode_java_leetcode_刷题_
09-30
本资料包聚焦于Java语言，整理了150多道LeetCode上的热门问题，是Java开发者进行刷题训练的理想资源。 LeetCode中的题目涵盖了数据结构、算法、设计模式等多个方面，每道题目都分为Easy、Medium、Hard三个难度级别...
用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录_Java_下载.zip
04-30
在本压缩包“用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录_Java_下载.zip”中，包含的资源主要是关于Java编程语言实现的数据结构、排序算法、经典算法以及LeetCode刷题的代码实现。这些是计算机...
leetcode刷题全刷-Leetcode_Brush_Questions_Everyday:Leetcode_Brush_Questions
06-30
leetcode刷题全刷 Leetcode_Brush_Questions_Everyday 考研成功上岸，毕业论文也已写完，突然闲下来感觉身体上和精神上都受不了，正好趁此机会提高提高自己的编程能力。虽然以前学过c，python，但是自以为写的代码太...
leetcode刷题账号-LeetCode:LeetCode刷题记录(C#)
07-06
这个压缩包文件"LeetCode-master"很可能包含了某个用户在刷题过程中的代码记录或者解决方案。 在刷LeetCode的过程中，有几个关键知识点是值得深入探讨的： 1. **基础数据结构**：在LeetCode的题目中，常见数据结构...
leetcode316-leetcode_problems:LeetCode刷题记录
06-30
刷题记录 题目顺序无规律，My Code皆使用Python3语言。标题开头表示该题的难易度分类：(E)为Easy、(M)为Medium、(H)为Hard 单纯是我个人解题当下的纪录，不会是唯一或最佳解。 (M) 39. Combination Sum Description ...
实现一个计算输入的两数的和与差的简单函数。
热门推荐
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 1369
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 1125
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 746
leetcode
wy的leetcode刷题记录_Day37
m0_54015435的博客
11-08 676
leetocode
7-1 数组元素循环右移问题
m0_54015435的博客
05-10 641
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 574
练习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 539
2022-11-30 每日一题：灵活使用STL+二叉树的后序遍历
"详细代码解析：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、付费专栏及课程。

余额充值