力扣贪心算法专题（三）力扣题 452、435、763、56、738、968、714 思路及C++实现

最新推荐文章于 2024-01-26 15:18:40 发布
最新推荐文章于 2024-01-26 15:18:40 发布
阅读量404 收藏 2
点赞数
分类专栏： C++刷题-LeetCode-牛客 文章标签： 贪心算法 leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/UUUUU22/article/details/130692377
版权

文章目录

贪心算法

  1. 贪心的本质是选择每一阶段的局部最优，从而达到全局最优。如何通过局部最优，推出整体最优。
  2. 贪心算法的套路就是常识性推导加上举反例。
  3. 贪心算法解题思路：想清楚局部最优是什么，如果推导出全局最优，就够了。

452. 用最少数量的箭引爆气球

在这里插入图片描述

思路：

  • 只射重叠最多的气球，用的弓箭一定最少。
  • 贪心算法局部最优：当气球出现重叠，一起射，所用弓箭最少。全局最优：把所有气球射爆所用弓箭最少。

做法：

  • 把气球排序，从前到后(从后向前)遍历气球，仅跳过被射过的气球，记录箭的数量。
  • 按照气球的起始位置排序，从前向后遍历气球数组，靠左尽可能让气球重复。如果气球重叠了，重叠气球中右边边界的最小值 之前的区间一定需要一个弓箭。
  • 例如，[[10,16],[2,8],[1,6],[7,12]]为例。排序后，[[1,6], [2,8], [7,12], [10,16]]。首先第一组重叠气球[1,6]和[2,8]，一定需要一支箭；[7,12]气球3的左边界大于了 第一组重叠气球[1,6]的最小右边界，所以还需要一支箭来射气球3。

代码：

class Solution {
public:
    static bool cmp(const vector<int>& a, const vector<int>& b)
    {
        return a[0]<b[0];
    }
    int findMinArrowShots(vector<vector<int>>& points) {
        if(points.size()==0) return 0;//如果没有气球 不需要箭
        sort(points.begin(), points.end(), cmp);//排序
        int result = 1;//至少需要一支箭
        for(int i=1; i<points.size(); i++)//注意从第二个气球开始
        {
            //如果气球不重叠 当前气球的头 在 上一个气球的尾后面 需要一只箭
            //不取= 是因为题目中满足xstart ≤ x ≤ xend，则该气球会被引爆。
            //那么说明两个气球挨在一起不重叠也可以一起射爆
            if(points[i][0] > points[i-1][1]) result++;
            //如果气球重叠  更新重叠气球最小右边界
            else points[i][1] = min(points[i-1][1], points[i][1]);
        }
        return result;
    }
};

435. 无重叠区间

做法1 右边界排序 不重叠区间

思路： 这和452.用最少数量的箭引爆气球非常像，弓箭数相当于是非交叉区间的数量。不同的是，题目中认为[0，1]和[1，2]不是相邻区间，注意判断条件的修改，然后用总区间数减去弓箭数量 就是要移除的区间数量了。

代码：

class Solution {
public:
    static bool cmp_r(const vector<int>& a, const vector<int>& b)
    {
        return a[1] < b[1];
    }
    static bool cmp_l(const vector<int>& a, vector<int>& b)
    {
        return a[0] < b[0];
    }

    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if(intervals.size()==0) return 0;
       
        //做法1 右边界排序 重叠区间
        sort(intervals.begin(), intervals.end(), cmp_r);
        int count = 1;//不重叠区间数
        for(int i=1; i<intervals.size(); i++)
        {
            //注意 [0，1]和[1，2]不是相邻区间
            if(intervals[i][0] >= intervals[i-1][1]) count++;
            else intervals[i][1] = min(intervals[i][1], intervals[i-1][1]);
        }
        return intervals.size() - count;
    }
};

做法2 右边界排序 不重叠区间

思路： 让区间尽可能重叠，首先右边界按照从小到大排序，从左向右遍历记录非交叉区间的个数，最后用区间总数减去非交叉区间的个数就是需要移除的区间个数了。

代码：

class Solution {
public:
    static bool cmp_r(const vector<int>& a, const vector<int>& b)
    {
        return a[1] < b[1];
    }
    static bool cmp_l(const vector<int>& a, vector<int>& b)
    {
        return a[0] < b[0];
    }

    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if(intervals.size()==0) return 0;

        //做法2 右边界排序 不重叠区间
        sort(intervals.begin(), intervals.end(), cmp_r);
        int count = 1;//记录非交叉区间的个数
        int end = intervals[0][1];//分割点
        for(int i=1; i<intervals.size(); i++)
        {
            //如果当前区间的尾巴 在 上一个区间的头前面 说明不重叠
            if(end <= intervals[i][0])
            {
                count++;
                end = intervals[i][1];//更新区间尾巴
            }
        }
        return intervals.size() - count;
    }
};

做法3 左边界排序 重叠区间

代码：

class Solution {
public:
    static bool cmp_r(const vector<int>& a, const vector<int>& b)
    {
        return a[1] < b[1];
    }
    static bool cmp_l(const vector<int>& a, vector<int>& b)
    {
        return a[0] < b[0];
    }

    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if(intervals.size()==0) return 0;

        //做法3 左边界排序 重叠区间
        sort(intervals.begin(), intervals.end(), cmp_l);
        int count = 0;//记录重叠区间
        for(int i=1; i<intervals.size(); i++)
        {
            //如果当前区间的头 在 上一个区间的尾巴前面 说明重叠
            //注意 [0，1]和[1，2]不是相邻区间
            if(intervals[i][0] < intervals[i-1][1])
            {
                intervals[i][1] = min(intervals[i][1], intervals[i-1][1]);//更新最小右边界
                count++; 
            }
        }
        return count;
    }
};

763.划分字母区间

在这里插入图片描述

做法1

思路：
用最远出现距离模拟了圈字符的行为，要找每一个字母的边界，如果找到之前遍历过的所有字母的最远边界，说明这个边界就是分割点了，可以分为如下两步：

  • 统计每一个字符最后出现的位置；
  • 从头遍历字符，并更新字符的最远出现下标，如果找到字符最远出现位置下标和当前下标相等了，则找到了分割点。

代码：

class Solution {
public:
    vector<int> partitionLabels(string s) {
        int hash[27] = {0};//保存字母最后出现的位置 
        //统计字母最后出现的位置
        //i为字符，hash[i]为字符出现的最后位置
        for(int i=0; i<s.size(); i++)
        {
            hash[s[i] - 'a'] = i;
        }
        vector<int> result;
        int left = 0;
        int right = 0;
        //找到最远边界
        for(int i=0; i<s.size(); i++)
        {
            right = max(right, hash[s[i] - 'a']);
            if(i == right)//最远边界和下标相同
            {
                result.push_back(right - left + 1);
                left = i + 1;//left要更新 跳到i+1位置开始新的划分起点
            }
        }
        return result;
    }
};

做法2

思路：
统计字符串中所有字符的起始和结束位置，记录这些区间，实际上也就是435.无重叠区间题目里的输入，将区间按左边界从小到大排序，找到边界将区间划分成组，互不重叠，找到的边界就是答案。
首先要获得435.无重叠区间题目里的输入，然后按照435.无重叠区间题目里的思路去写。

代码：

class Solution {
public:
    //做法2
    //首先获得区间输入
    vector<vector<int>> countLabels(string s)
    {
        vector<vector<int>> hash(26, vector<int>(2, INT_MIN));//记录区间 默认26哥字母
        vector<vector<int>> hash_filter;
        //记录每个字母出现的起始位置
        for(int i=0; i<hash.size(); ++i)
        {
            if(hash[s[i] - 'a'][0] == INT_MIN) hash[s[i] - 'a'][0] = i;//最开始位置
            hash[s[i] - 'a'][1] = i;//最末尾位置
        }
        //去掉s中没有出现的字母的区间
        for(int i=0; i<s.size(); ++i)
        {
            if(hash[i][0] != INT_MIN) hash_filter.push_back(hash[i]);//存放出现字母对应区间
        }
        return hash_filter;
    }

    //排序 左边界排序
    static bool cmp(vector<int>& a, vector<int>& b)
    {
        return a[0] < b[0];
    }
    //找出重叠区间的长度个数
    vector<int> partitionLabels(string s)
    {
        vector<int> result;//记录区间分割点
        //获得s各字母的起始区间
        vector<vector<int>> hash = countLabels(s);
        sort(hash.begin(), hash.end(), cmp);//按照左边界排序
        int right = hash[0][1];// 记录最大右边界
        int left = 0;
        //找到分割点
        for(int i=1; i<hash.size(); ++i)
        {
            //当前区间的头 在 上一区间的尾部 前面
            if(hash[i][0] > right)
            {
                result.push_back(right - left + 1);//存放长度
                left = hash[i][0];//left左边界更新 找下一个重叠区间长度
            }
            right = max(right, hash[i][1]);//right最远右边界更新 找下一个重叠区间长度
        }
        result.push_back(right - left + 1);//最右端
        return result;
    }
};

56. 合并区间

在这里插入图片描述

思路：
和435.无重叠区间题目思路类似，找重叠区间，不同的是用合并区间后左边界和右边界，作为一个新的区间，加入到result数组里就可以了。如果没有合并就把原区间加入到result数组。

代码：

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        vector<vector<int>> result;
        //lambda表达式 左边界排序
        sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b){return a[0] < b[0];});
        //左边界排序后 result.back()的左边界一定是最小值 只需要跟新右区间
        result.push_back(intervals[0]);//先存放第一个区间左边界 肯定是最小的边界
        for(int i=1; i<intervals.size(); i++)
        {
            // 区间重叠 当前区间的头部 在上一个区间的 尾部前面
            if(result.back()[1] >= intervals[i][0]) result.back()[1] = max(result.back()[1], intervals[i][1]);
            else result.push_back(intervals[i]);// 区间不重叠
        }
        return result;
    }
};

738.单调递增的数字

在这里插入图片描述

暴力解法

依次取位，从个位开始向高位依次判断，数字是否递增；从大到小遍历

代码：

class Solution {
private:
    bool isup(int num)
    {
        int max = 10, temp = 0;//个位最大取9
        while(num)
        {
            temp = num % 10;
            if(max >= temp) max = temp;
            else return false;
            num = num / 10;//前进一位
        }
        return true;
    }
public:
    int monotoneIncreasingDigits(int n) {
        for(int i=n; i>=0; i--)//从大到小逐个判断
        {
            if(isup(i)) return i;
        }
        return 0;
    }
};

贪心算法

一个两位数xy，找小于等于xy的最大单调递增整数，如果x＞y，让x–，y=9，即（x-1）9；如果x≤y，不变。从后向前遍历数字。
不可以从前往后遍历，如果按照上述操作，对于三位数等多位数有可能会导致结果不对，例如543，从前往后遍历就变成了439，百位大于十位，不是单调递增数字。从后往前遍历，就是543→539→499

代码：

class Solution {
//贪心算法
public:
    int monotoneIncreasingDigits(int n) {
        //先转成字符串
        string strnum = to_string(n);
        //标记赋值9从哪里开始,设置默认值为strnum.size()
        //防止第二个for循环在flag没有被赋值的情况下执行
        int mark = strnum.size();
        for(int i = strnum.size()-1; i>0; i--)
        {
            if(strnum[i-1] > strnum[i]) 
            {
                mark = i;//标记
                strnum[i-1]--;
            }
        }
        //在标记位置赋值为9
        for(int i = mark; i<strnum.size(); i++)
        {
            strnum[i] = '9';
        }
        return stoi(strnum);
    }

};

968.监控二叉树

分析：

  1. 摄像头都没有在叶子节点上。如果放在叶子节点上，就会浪费一层覆盖；放在叶子节点的父节点位置，才能充分利用摄像头的覆盖面积，即摄像头可以覆盖上中下三层。
  2. 从下往上看。如果从上往下看，头结点不放置，可以省一个摄像头。

思路：
从下往上遍历，后序遍历，左右中顺序，回溯时先给叶子节点父节点放个摄像头，然后隔两个节点放一个摄像头，直至到二叉树头结点。
局部最优：让叶子节点的父节点安摄像头，所用摄像头最少，整体最优：全部摄像头数量所用最少。

如何放置摄像头？
状态转移的公式，三个数字来表示：
0：该节点无覆盖
1：本节点有摄像头
2：本节点有覆盖
空节点的状态只能是有覆盖，无摄像头就是无覆盖或者有覆盖的状态

单层递归的四种情况：

  1. 情况1：左右节点都有覆盖，那么中间节点就是无覆盖了
  2. 情况2：左右节点至少有一个无覆盖的情况，则中间节点（父节点）应该放摄像头：
  • left == 0 && right == 0 左右节点无覆盖
  • left == 1 && right == 0 左节点有摄像头，右节点无覆盖
  • left == 0 && right == 1 左节点有无覆盖，右节点摄像头
  • left == 0 && right == 2 左节点无覆盖，右节点覆盖
  • left == 2 && right == 0 左节点覆盖，右节点无覆盖
    此时摄像头的数量要加一，并且return 1，代表中间节点放摄像头。
  1. 情况3：左右节点至少有一个有摄像头，那么其父节点就是覆盖的状态
  • left == 1 && right == 2 左节点有摄像头，右节点有覆盖
  • left == 2 && right == 1 左节点有覆盖，右节点有摄像头
  • left == 1 && right == 1 左右节点都有摄像头
  1. 头结点没有覆盖，递归结束之后，还要判断根节点，如果没有覆盖，result++

代码：

class Solution {
private:
    int result;
    /*
    0---无覆盖
    1---有摄像头
    2---有覆盖
    */
    int traversal(TreeNode* cur)
    {
        //空节点，该节点有覆盖
        if(cur == NULL) return 2;
        int left = traversal(cur->left);
        int right = traversal(cur->right);

        //1.左右都有节点 中间节点无覆盖
        if(left == 2 && right == 2) return 0;
        //2.左右节点至少有一个是覆盖  中间节点放摄像头
        if(left == 0 || right == 0)
        {
            result++;
            return 1;
        }
        //3.左右节点至少有一个有摄像头 中间节点有覆盖
        if(left == 1 || right == 1) return 2;

          return -1;
    }

public:
    int minCameraCover(TreeNode* root) {
        result = 0;
        //4.判断头结点无覆盖 +1
        if(traversal(root) == 0) result++;
        return result;
    }
};

714.买卖股票的最佳时机含手续费

在这里插入图片描述
思路：
涉及手续费，要考虑什么时候买卖股票，因为有可能买卖利润不足以支付手续费。
最低价买股票，即买入日期，此时股价最小值。
扣除手续费的最高价卖股票，即卖出日期。只要当前价格大于最低价格+手续费，就可以收获利润。而最终的卖出日期是连续收获利润区间里的最后一天。
收获利润操作时的三种情况：
情况一：最低价时，买入股票
情况二：不买不卖，保持原有状态，买不便宜，卖亏本
情况三：当前价格大于最低价格+手续费时卖出股票，计算利润，不是真的卖出股票，同时记录最小价格，最后一次计算计算利润才是真的卖出股票

代码：

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int result = 0;
        int minprice = prices[0];
        for(int i=1; i<prices.size(); i++)
        {
            //低价买入 买入日期
            if(prices[i] < minprice) minprice = prices[i];

            //不买不卖 买不便宜 卖亏本
            if(prices[i] >= minprice && prices[i] <= minprice+fee) continue;

            //计算利润 最后一天计算利润才是真的卖出日期
            if(prices[i] > minprice+fee)
            {
                result += prices[i] - minprice - fee;
                minprice = prices[i] - fee;//每天要更新最低价格
            }
        }
        return result;
    }
};
虚假自律就会真自律！
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
力扣刷题c++贪心算法.zip
04-25
贪心算法 一般来说，贪婪算法有五个组成部分: 一个候选集：从中创建一个解决方案 一个选择函数：用于选择要添加到解决方案中的最佳候选项 一个可行性函数：用于确定候选项是否可以为解决方案做出贡献 一个目标函数：为解决方案或部分解决方案赋值 解决方案函数：它将指示我们何时发现了完整的解决方案 贪婪算法对一些数学问题能够产生很好的解决方案，但对另一些其他数学问题却没有。他们解决的大多数问题都有两个属性: 贪婪选择的属性 我们可以做出目前看来最好的选择，然后解决以后出现的子问题。贪婪算法做出的选择可能取决于迄今为止做出的所有选择，但不取决于未来的选择或子问题的所有解决方案。它反复地做出一个又一个贪婪的选择，把每个给定的问题都简化成一个较小的问题。换句话说，贪婪的算法从不重新考虑它的选择。这也是与动态编程的主要区别，动态编程是详尽的，并且保证能够找到解决方案。在每个阶段之后，动态编程基于前一阶段做出的所有决策做出决策，并且可能会重新考虑前一阶段的算法求解路径。 最优子结构 "如果问题的最优解包含子问题的最优解，则该问题表现出最优子结构
LeetCode -贪心/双指针/二分查找/排序
weixin_39505091的博客
01-31 925
文章目录一. 贪心算法二. 双指针1. 典型 Two Sum2. 归并数组3. 快慢指针 一. 贪心算法 二. 双指针 1. 典型 Two Sum 例题167。采用相反的两个指针遍历数组。一个初始指向最小的元素，即数组最左边，向右遍历；一个初始指向最大的元素，即数组最右边，向左遍历。 2. 归并数组 例题88。归并两个有序数组使之成为一个有序数组。如果不重新开辟空间，直接将数组b中的元素插入到数组a中，会出现数组a后续的元素被覆盖的情况（元素需要不断后移）。 所以，如果数组的数据有被覆盖的风险，可以记得用倒
【算法】【C++、贪心、排序】力扣100161. 划分数组并满足最大差限制
未来就在脚下。
12-17 743
贪心算法是一种在每一步选择当前看来最好的方案的算法。它不考虑未来的影响，只考虑当前的局部最优解。贪心算法通常用于解决一些具有子结构最优性质的问题，即问题的最优解可以由其子问题的最优解组合而成。初始化：将问题分解成若干个子问题，并初始化一个空解集。选择：在当前子问题中，选择一个当前看来最好的方案。合并：将选出的方案添加到解集中，并更新子问题。重复：重复步骤 2 和 3，直到所有子问题都被解决。贪心算法的优点是简单易懂，并且在某些情况下可以找到最优解。
力扣刷题指南——贪心算法
JJJasmine的H君的博客
10-18 1677
一、什么是贪心算法
力扣 贪心算法题集 Python
荷碧TongZJ 的水文
03-10 2838
贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择，就能得到问题的答案。贪心算法需要充分挖掘题目中条件，没有固定的模式，解决有贪心算法需要一定的直觉和经验。 贪心算法不是对所有问题都能得到整体最优解。能使用贪心算法解决的问题具有「贪心选择性质」。「贪心选择性质」严格意义上需要数学证明。能使用贪心算法解决的问题必须具备「无后效性」，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。 从力扣官网对贪心算法的介绍来看，学贪心算法真就需要题海战术。记录一下有价值的题目吧 .
力扣第128题 最长连续序列 c++暴力简单易懂
lenyan~的博客
09-10 533
中等给定一个未排序的整数数组nums，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。请你设计并实现时间复杂度为O(n)的算法解决此问题。4最长数字连续序列是9> Problem: [128. 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence/description/)[TOC]
力扣链表算法(c++)（代码随想录链表部分）
qq_57960105的博客
01-10 377
力扣链表算法(c++)（代码随想录链表部分）
力扣方法总结：贪心算法
南航小菜鸡
05-21 1425
942. 增减字符串匹配 Easy 贪心 2022/5/12 由范围 [0,n] 内所有整数组成的 n + 1 个整数的排列序列可以表示为长度为 n 的字符串 s ，其中: 如果 perm[i] < perm[i + 1] ，那么 s[i] == ‘I’ 如果 perm[i] > perm[i + 1] ，那么 s[i] == ‘D’ 给定一个字符串 s ，重构排列 perm 并返回它。如果有多个有效排列perm，则返回其中 任何一个 。 示例： 输入：s = “IDID” 输出：[0,4
写比较器出现ava.lang.IllegalArgumentException: Comparison method violates its general contract!异常
Untara的博客
05-13 247
Arrays.sort(intervals, new Comparator<int[]>() { @Override public int compare(int[] o1, int[] o2) { if(o1[0]> o2[0]) return 1; else if(o1[0] < o2[0]) return -1; else{ .
452. 用最少数量的箭引爆气球-贪心算法-Comparator比较器使用
hequnwang10的博客
03-24 836
一、题目描述 有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。 一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出
C#实现力扣双周赛算法题：以组为单位订音乐会的门票订购
06-14
C#实现力扣双周赛算法题：以组为单位订音乐会的门票订购 还有python实现的算法
Python算法题源代码-LeetCode(力扣)-全排列
02-26
力扣热题Python源代码 题目46. 全排列 给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。 示例 1： 输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1...
Python算法题源代码-LeetCode(力扣)-子集
02-27
力扣热题Python源代码 题目78. 子集 给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。 示例 1： 输入：nums = [1,2...
Python算法题源代码-LeetCode(力扣)-搜索插入位置
最新发布
03-07
力扣热题Python源代码 题目35. 搜索插入位置 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 请必须使用时间复杂度为 O(log n) 的...
leetcode 经典贪心算法题目(思路、方法、code)
Ding 的博客
05-03 3717
用于回顾数据结构与算法时刷题的一些经验记录 (提出对应的贪心算法时最好自己举例子试试能否可行) 文章目录[455. 分发饼干](https://leetcode-cn.com/problems/assign-cookies/)[376. 摆动序列](https://leetcode-cn.com/problems/wiggle-subsequence/)[402. 移掉K位数字](https://...
力扣LeetCode-贪心算法
weixin_56005963的博客
03-04 2301
贪心算法 基本知识 1.思想 基于局部最优的选择逐渐推导出全局最优解 2.一般步骤 将问题分解为若干个子问题； 找出合适的贪心策略； 求解每一个子问题的最优解； 将局部最优解合成为全局最优解； 典型例题 1. LeetCode 376. 摆动序列 题目 如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为 摆动序列 。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。 例如， [1, 7, 4, 9
435. 无重叠区间 - 力扣（LeetCode）
weixin_48613005的博客
01-26 500
给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi]。返回 需要移除区间的最小数量，使剩余区间互不重叠。将数组按照左边界或者右边界从小到大排序，目的是为了将容易重叠的区间放在一块，本题解采用左边界排序。输入: intervals = [[1,2],[2,3],[3,4],[1,3]]解释: 移除 [1,3] 后，剩下的区间没有重叠。
贪心算法——重叠区间问题（力扣435 ，452题）
weixin_51818357的博客
12-14 1606
重叠区间 给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。 注意: 可以认为区间的终点总是大于它的起点。 区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。 示例 1: 输入: [ [1,2], [2,3], [3,4], [1,3] ] 输出: 1 解释: 移除 [1,3] 后，剩下的区间没有重叠。 示例 2: 输入: [ [1,2], [1,2], [1,2] ] 输出: 2 解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。 示例 3: 输入: [ [
C++ STL之 vector（动态数组）详解
zdlzf的博客
06-16 4369
vector为可变长数组（动态数组），定义的vector数组可以随时添加数值和删除元素。在局部函数中开vector数组，是在堆空间里面开的，与开全局变量比较类似，所以经常见到在局部函数中开大容量数组。1.头文件2.初始化一维初始化//定义了一个名为num的存int数据的一维数组//定义了一个名为num的存double数据的一维数组//node是结构体类型1.指定长度和初始值的初始化//定义一个长度为n的数组，动态定义，不指定初值默认初值为0//所有的元素均为0。
javascript力扣算法题库
10-12
好的，你想了解 JavaScript力扣算法题库，这是一个非常好的主题。JavaScript力扣算法题库是一个包含各种算法问题的在线平台，它提供了许多有趣的问题，可以帮助你提高你的编程技能。你可以在这个平台上找到各种难度...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值