leetcode总结 DAY 26-32 贪心

最新推荐文章于 2024-06-14 05:45:37 发布
最新推荐文章于 2024-06-14 05:45:37 发布
阅读量131 收藏
点赞数
文章标签： leetcode 算法 贪心算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ShirleyZ1007/article/details/129569892
版权

贪心

贪心的本质是选择每一阶段的局部最优，从而达到全局最优。

贪心算法并没有固定的套路。

如何验证可不可以用贪心算法呢？ 最好用的策略就是举反例，如果想不到反例，那么就试一试贪心吧。

455.分发饼干

力扣题目链接(opens new window)

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

这里的局部最优就是大饼干喂给胃口大的，充分利用饼干尺寸喂饱一个，全局最优就是喂饱尽可能多的小孩。

public int findContentChildren(int[] g, int[] s) {
    Arrays.sort(g);
    Arrays.sort(s);
    int i=g.length-1, j=s.length-1;
    int count = 0;
    while(i>=0 && j>=0){
        if(s[j]>=g[i]){
            count++;
            j--;
        }
        i--;
    }
    return count;
}

376. 摆动序列

力扣题目链接(opens new window)

如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。

例如， [1,7,4,9,2,5] 是一个摆动序列，因为差值 (6,-3,5,-7,3) 是正负交替出现的。相反, [1,4,7,2,5] 和 [1,7,4,5,5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。

给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。

53. 最大子序和

力扣题目链接(opens new window)

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算“连续和”，因为负数加上下一个元素 “连续和”只会越来越小。

全局最优：选取最大“连续和”

局部最优的情况下，并记录最大的“连续和”，可以推出全局最优。

    public int maxSubArray(int[] nums) {
        int sum = 0, max=nums[0];
        for(int j=0;j<nums.length;j++){
            // sum+nums[j]<nums[j] ==> sum<0
            sum = sum<0?nums[j]:sum+nums[j];
            max = Math.max(max,sum);
        }
        return max;
    }

122.买卖股票的最佳时机II

力扣题目链接(opens new window)

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

局部最优：收集每天的正利润，全局最优：求得最大利润。

    public int maxProfit(int[] prices) {
        int maxPro = 0;
        for(int i=1;i<prices.length;i++){
            maxPro += Math.max(prices[i]-prices[i-1],0);
        }
        return maxPro;
    }

滑动窗口：当第i天利润大于前一天利润，更新收益值，否则抛出股票，重新在第i天买入

    public int maxProfit(int[] prices) {
        int maxPro = 0;
        int preDif = 0, curDif = 0;
        for(int l=0,i=1;i<prices.length;i++){
            curDif = prices[i]-prices[l];
            if(curDif<preDif){
                l = i;
                preDif = 0;
                continue;
            }
            maxPro += (curDif-preDif);
            preDif = curDif;
        }
        return maxPro;
    }

55. 跳跃游戏

力扣题目链接(opens new window)

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个位置。

跳几步无所谓，关键在于可跳的覆盖范围！问题可转化为跳跃覆盖范围究竟可不可以覆盖到终点！

贪心算法局部最优解：每次取最大跳跃步数（取最大覆盖范围），整体最优解：最后得到整体最大覆盖范围，看是否能到终点。

    public boolean canJump(int[] nums) {
        int r = 0; // 用于记录最大可达的数组下表
        for(int i=0;i<nums.length;i++){
            if(i>r) break;
            r = Math.max(r,i+nums[i]);
        }
        return r<nums.length-1?false:true;
    }

45.跳跃游戏II

力扣题目链接(opens new window)

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

你的目标是使用最少的跳跃次数到达数组的最后一个位置。

局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。整体最优：一步尽可能多走，从而达到最小步数。

    public int jump(int[] nums) {
        int count = 0; // 跳跃次数
        int curDis = 0; // 当前步子最大可达范围
        int nextDis = 0; // 下一步最大可达范围
        for(int i=0;i<nums.length-1;i++){
            nextDis = Math.max(nextDis,i+nums[i]);
            if(nextDis>=nums.length-1){
                count++;
                break;
            }
            if(i==curDis){
                curDis = nextDis;
                count++;
            }
        }
        return count;
    }

    public int jump(int[] nums) {
        int count = 0; // 跳跃次数
        int curDis = 0; // 当前步子最大可达范围
        int nextDis = 0; // 下一步最大可达范围
        for(int i=0;i<=curDis && curDis<nums.length-1;i++){
            nextDis = Math.max(nextDis,i+nums[i]);
            if(i==curDis){
                curDis = nextDis;
                count++;
            }
        }
        return count;
    }

1005.K次取反后最大化的数组和

力扣题目链接(opens new window)

给定一个整数数组 A，我们只能用以下方法修改该数组：我们选择某个索引 i 并将 A[i] 替换为 -A[i]，然后总共重复这个过程 K 次。（我们可以多次选择同一个索引 i。）

以这种方式修改数组后，返回数组可能的最大和。

两次贪心：

  1. 局部最优：让绝对值大的负数变为正数，当前数值达到最大，整体最优：整个数组和达到最大。

  2. 如果将负数都转变为正数了，K依然大于0，此时的问题是一个有序正整数序列，如何转变K次正负，让 数组和 达到最大。此时，局部最优：只找数值最小的正整数进行反转，当前数值和可以达到最大，全局最优：整个 数组和 达到最大。

    public int largestSumAfterKNegations(int[] nums, int k) {
        Arrays.sort(nums);
        int sum = 0;
        int min = Integer.MAX_VALUE; // 记录nums中最小的数字
        for(int i=0;i<nums.length;i++){
            if(nums[i]<0 && k>0){ // 保证nums[i]中变后的数字都为正数
                nums[i] = -nums[i];
                k--;
            }
            min = Math.min(min,nums[i]);
            sum += nums[i];
        }
        if(k>0 && k%2==1){ 
            sum -= 2*min; // 只有当k为奇数时，需要给min乘-1，即sum减去两个min
        }
        return sum;
    }

134. 加油站

力扣题目链接(opens new window)

在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。

你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。

如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。

首先如果总油量减去总消耗大于等于零那么一定可以跑完一圈，说明 各个站点的加油站 剩油量rest[i]=gas[i] - cost[i]相加一定是大于等于零的。

i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。

局部最优：当前累加rest[i]的和curSum一旦小于0，起始位置至少要是i+1，因为从i之前开始一定不行。全局最优：找到可以跑一圈的起始位置。

    public int canCompleteCircuit(int[] gas, int[] cost) {
        int totalSum = 0; // 记录走完全程后油箱内剩余油量
        int curSum = 0; // 记录从start开始到i时邮箱内剩余油量
        int start = 0; // 起点
        for(int i=0;i<gas.length;i++){
            totalSum += gas[i]-cost[i];
            curSum += gas[i]-cost[i];
            if(curSum<0){
                curSum = 0;
                start = i+1;
            }
        }
        return totalSum<0?-1:start;
    }

135. 分发糖果

力扣题目链接(opens new window)

老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。

你需要按照以下要求，帮助老师给这些孩子分发糖果：

  • 每个孩子至少分配到 1 个糖果。
  • 相邻的孩子中，评分高的孩子必须获得更多的糖果。

那么这样下来，老师至少需要准备多少颗糖果呢？

思路：

遇到需要考虑两边的情况，要先固定一边，确定完情况一后，再考虑情况二

从两边分别考虑

1.左<右 此时局部最优：只要右边评分比左边大，右边的孩子就多一个糖果，全局最优：相邻的孩子中，评分高的右孩子获得比左边孩子更多的糖果

2.右>左

局部最优：取candyVec[i + 1] + 1 和 candyVec[i] 最大的糖果数量，保证第i个小孩的糖果数量既大于左边的也大于右边的。全局最优：相邻的孩子中，评分高的孩子获得更多的糖果。

左孩子大于右孩子的情况一定要从后向前遍历，因为 rating[5]与rating[4]的比较 要利用上 rating[5]与rating[6]的比较结果，所以 要从后向前遍历。

    public int candy(int[] ratings) {
        int len = ratings.length;
        int[] candyNum = new int[len];
        candyNum[0] = 1;
        for(int i=1;i<len;i++){
            candyNum[i] = ratings[i-1]<ratings[i]?candyNum[i-1]+1:1;
        }
        int sum = candyNum[len-1];
        for(int i=len-2;i>=0;i--){
            if(ratings[i]>ratings[i+1]){
                candyNum[i] = Math.max(candyNum[i],candyNum[i+1]+1);
            }
            sum += candyNum[i];
        }
        return sum;
    }

860.柠檬水找零

力扣题目链接(opens new window)

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。

注意，一开始你手头没有任何零钱。

如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

三种情况：

  • 情况一：账单是5，直接收下。

  • 情况二：账单是10，消耗一个5，增加一个10

  • 情况三：账单是20，优先消耗一个10和一个5，如果不够，再消耗三个5

    美元10只能给账单20找零，而美元5可以给账单10和账单20找零，美元5更万能！

    局部最优：遇到账单20，优先消耗美元10，完成本次找零。全局最优：完成全部账单的找零

    public boolean lemonadeChange(int[] bills) {
        int fiveNum = 0, tenNum = 0;
        for(int i=0;i<bills.length;i++){
            if(bills[i]==5) fiveNum += 1;
            else if(bills[i]==10){
                if(fiveNum==0) return false;
                fiveNum -= 1;
                tenNum += 1;
            }else{
                // 没5 或 没10且5不够三张
                if(fiveNum==0 || (tenNum==0 && fiveNum<3)) return false;
                // 有10：找一张10和一张5
                if(tenNum>0){
                    fiveNum -= 1;
                    tenNum -= 1;
                }else{
                    // 无10：找三张5
                    fiveNum -= 3;
                }               
            }
        }
        return true;
    }

406.根据身高重建队列

力扣题目链接(opens new window)

假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。

请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。

按身高从大到小排，身高相同，k按从小到大排。按照身高排序之后，优先按身高高的people的k来插入，后序插入节点也不会影响前面已经插入的节点，最终按照k的规则完成了队列。

局部最优：优先按身高高的people的k来插入。插入操作过后的people满足队列属性

全局最优：最后都做完插入操作，整个队列满足题目队列属性

    public int[][] reconstructQueue(int[][] people) {
        // 按h降序排序，若h相同，则k按升序排序
        Arrays.sort(people,new Comparator<int[]>(){
            public int compare(int[] o1, int[] o2){
                return o1[0]==o2[0]?o1[1]-o2[1]:o2[0]-o1[0];
            }
        });

        LinkedList<int[]> list = new LinkedList<>();
        // for(int[] p:people) list.add(p[1],p);
        for(int i=0;i<people.length;i++){
            list.add(people[i][1],people[i]); // h为降序，故第一个元素为最高的h，对应的k一定为0
        }
        return list.toArray(new int[people.length][]);
    }

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

力扣题目链接(opens new window)

在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。

一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。

给你一个数组 points ，其中 points [i] = [xstart,xend] ，返回引爆所有气球所必须射出的最小弓箭数。

为了让气球尽可能的重叠，需要对数组进行排序。此处按照气球的起始位置排序，故从前向后遍历气球数组，靠左尽可能让气球重复。

如果气球重叠了，重叠气球中右边边界的最小值 之前的区间一定需要一个弓箭。

    public int findMinArrowShots(int[][] points) {
        Arrays.sort(points, (o1,o2)->{
            // return o1[0]==o2[0]?o1[1]-o2[1]:o1[0]-o2[0]; // [[-2147483646,-2147483645],[2147483646,2147483647]]排序时溢出，排序结果为[2147483646, 2147483647][-2147483646, -2147483645]
            if(o1[0]==o2[0]) return o1[1]==o2[1]?0:o1[1]>o2[1]?1:-1;
            return o1[0]>o2[0]?1:-1;
        });

        int count = 1;
        for(int i=1;i<points.length;i++){
            // 1. 使用新箭情况：当前区间和前一个区间不重合
            if(points[i][0]>points[i-1][1]) count++;
            else{
                // 2. 当前区间和前一个区间有重合，共用一根箭。
                // 更新当前区间右边界后，可以判断下一个区间是否可以共用一根箭
                points[i][1] = Math.min(points[i][1],points[i-1][1]);
            }
        }
        return count;
    }

int排序溢出问题

[[-2147483646,-2147483645],[2147483646,2147483647]]排序时，o1[i]-o2[i]溢出，排序结果为[[2147483646, 2147483647][-2147483646, -2147483645]]，与预期不符合

        Arrays.sort(points, (o1,o2)->{
            return o1[0]==o2[0]?o1[1]-o2[1]:o1[0]-o2[0]; 
        });

**解决办法一：**避免运算，用比大小代替

        Arrays.sort(points, (o1,o2)->{
            if(o1[0]==o2[0]) return o1[1]==o2[1]?0:o1[1]>o2[1]?1:-1;
            return o1[0]>o2[0]?1:-1;
        });

**解决办法二：**使用Integer内置比较方法，不会溢出

		Arrays.sort(points, (a, b) -> Integer.compare(a[0], b[0]));

435. 无重叠区间

力扣题目链接(opens new window)

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

注意: 可以认为区间的终点总是大于它的起点。 区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。

    public int eraseOverlapIntervals(int[][] intervals) {
        Arrays.sort(intervals, (a,b)->Integer.compare(a[0],b[0]));
        int count = 0;
        for(int i=1;i<intervals.length;i++){
            if(intervals[i][0]<intervals[i-1][1]){
                intervals[i][1] = Math.min(intervals[i][1],intervals[i-1][1]);
                count++;
            }
        }
        return count;
    }

763.划分字母区间

力扣题目链接(opens new window)

字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。

方法一：

统计字符串中所有字符的起始和结束位置，记录这些区间(实际上也就是[435.无重叠区间 (opens new window)]题目里的输入)，将区间按左或右边界排序，找到边界将区间划分成组，互不重叠。找到的区间长度就是答案。

    public List<Integer> partitionLabels(String s) {
        // 1. letters[i]存放字母在s中 首次出现的位置 和 最后出现的位置
        int[][] letters = new int[26][2];
        for(int i=0;i<s.length();i++){
            char c = s.charAt(i);
            int index = c-'a'; // 字母在数组letters中的行索引
            if(letters[index][0]==0) {
                letters[index][0] = i+1;
                letters[index][1] = i+1;
            }else letters[index][1] = i+1;
        }
        // 2. 按 字母最后出现的位置(即右边界letters[][1]) 由大到小排序
        Arrays.sort(letters,(a,b)->Integer.compare(b[1],a[1]));
        // 3. 找出s从后往前的所有不重合子串 即 找letters不重叠区间
        List<Integer> res = new ArrayList<>();
        int curEnd = letters[0][1], i=1;  
        for(;i<26 && letters[i][0]!=0 && letters[i][1]!=0;i++){
            if(letters[i][1]>letters[i-1][0]){
                letters[i][0] = Math.min(letters[i-1][0],letters[i][0]);
            }else{
                res.add(0,curEnd-letters[i-1][0]+1);  
                curEnd = letters[i][1];
            }
        }
        // 最左端
        res.add(0,curEnd-letters[i-1][0]+1);
        return res;
    }

方法二：

找每一个字母的边界，如果找到之前遍历过的所有字母的最远边界，说明这个边界就是分割点了。此时前面出现过所有字母，最远也就到这个边界了。

    public List<Integer> partitionLabels(String s) {
        // 1. letters[i]存放字母在s中 最后出现的位置
        int[] letters = new int[26];
        for(int i=0;i<s.length();i++){
            char c = s.charAt(i);
            int index = c-'a'; // 字母在数组letters中的行索引
            letters[index] = i+1;
        }
        // 2. 从头遍历字符，并更新字符的最远出现下标，如果找到字符最远出现位置下标和当前下标相等了，则找到了分割点
        List<Integer> res = new ArrayList<>();
        int startIndex = 0, endIndex = 0;
        for(int i=0;i<s.length();i++){
            endIndex = Math.max(endIndex,letters[s.charAt(i)-'a']-1);
            if(i==endIndex){
                res.add(endIndex-startIndex+1);
                startIndex = i+1;
            }
        }
        return res;
    }

56. 合并区间

力扣题目链接(opens new window)

给出一个区间的集合，请合并所有重叠的区间。

    public int[][] merge(int[][] intervals) {
        // 左边界排序
        Arrays.sort(intervals, (a,b)->Integer.compare(a[0],b[0]));
        List<int[]> res = new ArrayList<>();
        int curStart = intervals[0][0]; // 重叠区间起始
        int curEnd = intervals[0][1]; // 重叠区间结束
        for(int i=1;i<intervals.length;i++){
            if(intervals[i][0]<= curEnd){
                // 1）若intervals[i]和重叠区间 有部分重叠，移动重叠区间右边界
                curEnd = Math.max(intervals[i][1],curEnd);
            }else{
                // 2）若intervals[i]和重叠区间区间不重叠
                 res.add(new int[]{curStart,curEnd});
                 // 开始寻找新一个重叠区间
                 curStart = intervals[i][0]; 
                 curEnd = intervals[i][1];
            }         
        }
        // 最右端
        res.add(new int[]{curStart,curEnd});
        return res.toArray(new int[res.size()][2]);
    }

738.单调递增的数字

力扣题目链接(opens new window)

给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。

（当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。）

    public int monotoneIncreasingDigits(int n) {
        char[] digitArr = Integer.toString(n).toCharArray();
        int start = digitArr.length; // 记录之后位数全变为9的起始位置
        for(int i=digitArr.length-1;i>0;i--){
            if(digitArr[i-1]>digitArr[i]){ 
                // 0是最小的，若digitArr[i-1]为0则一定有digitArr[i-1]==digitArr[i],故不会出现0需要减一变为负的情况
                start = i;
                digitArr[i-1] = (char)(digitArr[i-1]-1);
            }
        }
        for(int i=start;i<digitArr.length;i++){
            digitArr[i] = '9';
        }
        // string中09 也可以直接转成 int 的 9
        // return Integer.parseInt(new String(digitArr)); 
        return Integer.valueOf(new String(digitArr));
    }
啊夏同学
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
leetcode卡-Leetcode-May-30-day-Challenge:Leetcode-May-30-day-Challenge
07-06
leetcode卡力码 30 天 该存储库作为点对点通信渠道创建和维护，以便 CP 世界的新来者可以讨论他们对 Leetcode ...向“manthanchauhan/Leetcode-May-30-day-Challenge/master”提交 PR。 资源 教程：
leetcode刷题算法总结-LeetCode-31-day-May-2020-Challenge:包含我在31天-LeetCodeMay'2
06-30
leetcode刷题算法总结我与病毒式 LeetCode 月刊的冒险 - Code Everyday Challenge - 20 年 5 月版 所以在一个晴朗的日子（2020 年4 月 30 日），我随便打开了 LinkedIn ，我的订阅源中充斥着来自完成了LeetCode 4 月...
LeetCode_day31-34 贪心算法
weixin_44884273的博客
06-12 689
LeetCode_day31-34 贪心算法。
LeetCode_day36-37 贪心
weixin_44884273的博客
06-15 620
【代码】LeetCode_day36-37 贪心。
LeetCode 打卡day32-贪心算法之跳跃游戏I， II
weixin_45872648的博客
06-11 82
● 122.买卖股票的最佳时机II ● 55. 跳跃游戏 ● 45.跳跃游戏II
Leetcode--------贪心
qq_40128284的博客
08-25 335
455. 分发饼干 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。 对每个孩子i，都有一个胃口值g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干j，都有一个尺寸s[j]。如果s[j]>= g[i]，我们可以将这个饼干j分配给孩子i，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。 示例1: 输入: g = [1,2,3], s = [1,1] 输出: 1 解释: 你有三个孩子和两...
LeetCode-day08-881. 救生艇
小李的便利店
06-10 341
881. 救生艇
【LeetCode】Day37-贪心算法值得学习
qq_42433311的博客
01-12 161
注：day35，day36还未完全理解。暂不写在CSDN。 334.递增的三元子序列 给你一个整数数组nums ，判断这个数组中是否存在长度为 3 的递增子序列。 如果存在这样的三元组下标 (i, j, k)且满足 i < j < k ，使得nums[i] < nums[j] < nums[k] ，返回 true ；否则，返回 false 。 输入：nums = [1,2,3,4,5] 输出：true 解释：任何 i < j < k 的三元组都满足题意 ...
LeetCode 打卡day31--贪心算法之最大子数组和摆动数列
weixin_45872648的博客
06-10 55
今天是进入新的章节, 贪心算法.贪心算法其实就是在每一次选择的时候都找局部的最优解, 然后最后最终的结果就为全局的最优解. 但其实也也没有一个具体的模版来解决贪心算法, 具体问题具体分析吧.
leetcode每天5题-Day53-贪心2
weixin_44286392的博客
11-13 336
贪心-第二弹
leetcode每天5题-Day49-贪心1
weixin_44286392的博客
10-08 743
贪心-第一弹
linzeliang1222#LeetCode#Day34-动态规划系列1
07-25
70. 爬楼梯思路1（数学公式）利用斐波那契数列的公式即可代码public int climbStairs(int n) {复杂度分析时间复杂度：$O(logN
leetcode动态规划总结-leetcode-summary-c-plus-plus:LeetCode问题总结
07-01
leetcode动态规划总结Leetcode 总结 C++ 用 C++ 编写的 LeetCode 问题摘要。 请查看更多信息。 对于 Python 版本，请检查 . 对于 Java 版本，请检查 . 带*号的题号，表示本题与原题不同。 基本数据结构 - 广度优先...
leetcode中国-day-day-up:记录每天的学习
06-29
day-day-up 记录每天的学习 所有记录暂时移植到readme 从11月开始链接附上 尽量做到详细 9月17日 1 动态规划 0-1背包问题。 2 cnn特征图大小计算。 3 线性回归的描述以及基本假设。 4 leetcode 无重复字符的最长子串...
Golang | Leetcode Golang题解之第149题直线上最多的点数
weixin_66442839的博客
06-14 388
Golang | Leetcode Golang题解之第149题直线上最多的点数
【回溯】Leetcode 77. 组合【中等】
FLGB
06-11 263
你可以按 任何顺序 返回答案。
【代码随想录算法训练Day35】LeetCode 1005. K 次取反后最大化的数组和、LeetCode 134.加油站、LeetCode 135.分发糖果
qq_46121420的博客
06-11 234
贪心第三天
Java | Leetcode Java题解之第149题直线上最多的点数
最新发布
m0_57195758的博客
06-14 300
Java | Leetcode Java题解之第149题直线上最多的点数
leetcode中贪心算法
07-27
在LeetCode上，有许多使用贪心算法解决的问题。 其中一道经典的贪心算法题目是"Jump Game"（跳跃游戏）。题目要求判断能否从数组的第一个元素跳到最后一个元素，每个元素的值代表可以向后跳跃的最大步数。 解决这...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值