leetcode-贪心算法

最新推荐文章于 2023-12-27 11:29:23 发布
最新推荐文章于 2023-12-27 11:29:23 发布
阅读量872 收藏
点赞数
分类专栏： leetcode 文章标签： leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44847326/article/details/123802594
版权

贪心算法

1. leetcode 455 分发饼干

//1. leetcode 455 分发饼干

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int result = 0;
        int index = s.size() - 1;  //饼干数组的下标      

        for (int i = g.size() - 1; i >= 0; i--) {   //倒序
            if (index >= 0 && s[index] >= g[i]) {
                result++;
                index--;
            }
        }
        return result;
    }
};


// 从小到大
class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int result = 0;

        for (int i =0; i < s.size(); i++) {
            if (result < g.size() && g[result] <= s[i]) {
                result++;
            }
               
        }
        return result;
    }
};

2. leetcode 376 摆动序列

//2. leetcode 376 摆动序列

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if (nums.size() <= 1) return nums.size();
        int curDiff = 0;   //当前一对差值
        int preDiff = 0;   //前一对差值
        int result = 1;    //记录峰值个数，默认序列最右边有一个峰值
        for (int i  = 0; i < nums.size() - 1; i++) {
            curDiff = nums[i + 1] - nums[i];
            //出现峰值
            if ((curDiff > 0 && preDiff <= 0) || (preDiff >= 0 && curDiff < 0)) {
                result++;
                preDiff = curDiff;
            }
        }
        return result;
    }
};

3. leetcode 53 最大子数组和

//3. leetcode 53. 最大子数组和

//暴力解法
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int result = INT32_MIN;
        int count = 0;
        for (int i = 0; i < nums.size(); i++) {
            count = 0;
            for (int j = i; j < nums.size(); j++) {
                count += nums[j];
                result = count > result ? count : result;
            }
        }
        return result;
    }
};

//贪心
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int result = INT_MIN;
        int count = 0;
        for (int i = 0; i < nums.size(); i++) {
            count += nums[i];
            //取区间累计的最大值
            if (count > result) {
                result = count;
            }
            //重置最大子序起始位置
            if (count <= 0) count = 0;
        }
        return result;
    }
};

//动态规划
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        vector<int> dp(nums.size(), 0);
        dp[0] = nums[0];
        int result = dp[0];
        for (int i = 1; i < nums.size(); i++) {
            dp[i] = max(dp[i - 1] + nums[i], nums[i]);
            if (dp[i] > result) result = dp[i];
        }
        return result;
    }
};

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

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

//贪心
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0;
        for (int i = 1; i < prices.size(); i++) {
            result += max(prices[i] - prices[i - 1], 0);
        }
        return result;
    }
};

//动态规划
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        //dp[i][0] 第i天持有的最多现金
        //dp[i][1] 第i天持有股票后的最多现金
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2, 0));
        dp[0][0] -= prices[0];
        for (int i = 1; i < n; i++) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
        }
        return max(dp[n - 1][0], dp[n - 1][1]);
    }
};

5. leetcode 55 跳跃游戏

//5. leetcode 55 跳跃游戏

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int cover = 0;
        if (nums.size() == 1) return true;
        for (int i = 0; i <= cover; i++) {
            cover = max(i + nums[i], cover);
            if (cover >= nums.size() - 1) return true;
        }
        return false;
    }
};

6. leetcode 45 跳跃游戏 II

//6. leetcode 45 跳跃游戏 II
 
class Solution {
public:
    int jump(vector<int>& nums) {
        if (nums.size() == 1) return 0;
        int curDistance = 0;  //当前覆盖最远距离下标
        int ans = 0;  
        int nextDistance = 0;  //下一步覆盖最远距离下标
        for (int i = 0; i < nums.size(); i++) {
            //更新下一步覆盖最远距离下标
            nextDistance = max(nums[i] + i, nextDistance);
            //遇到当前覆盖最远距离下标=
            if (i == curDistance) {
                //遇到当前覆盖最远距离下标不是终点
                if (curDistance != nums.size() - 1) {
                    ans++;
                    curDistance = nextDistance;
                    if (nextDistance >= nums.size() - 1) break;
                } else break;  //当前覆盖最远距离下标是集合终点，不用做ans++操作，直接结束
            }
        }
        return ans;
    }
};

class Solution {
public:
    int jump(vector<int>& nums) {
        int curDistance = 0;
        int ans = 0;
        int nextDistance = 0;
        for (int i = 0; i < nums.size() - 1; i++) {
            nextDistance = max(nums[i] + i, nextDistance);
            if (i == curDistance) {
                curDistance = nextDistance;
                ans++;
            }
        }
        return ans;
    }
};

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

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

class Solution {
static bool cmp(int a, int b) {
    return abs(a) > abs(b);
}
public:
    int largestSumAfterKNegations(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end(), cmp);
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] < 0 && k > 0) {
                nums[i] *= -1;
                k--;
            }
        }
        if (k % 2 == 1) nums[nums.size() - 1] *= -1;
        int result = 0;
        for (int num : nums) result += num;
        return result;
    }
};

8. leetcode 134 加油站

//8. leetcode 134 加油站


//暴力解法
class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        for (int i = 0; i < cost.size(); i++) {
            int rest = gas[i] - cost[i];
            int index = (i + 1) % cost.size();
            while (rest > 0 && index != i) {
                rest += gas[index] - cost[index];
                index = (index + 1) % cost.size();
            }
            if (rest >= 0 && index == i) return i;
        }
        return -1;
    }
};

//贪心
class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int curSum = 0;
        int min = INT_MAX;
        for (int i = 0; i < gas.size(); i++) {
            int rest = gas[i] - cost[i];
            curSum += rest;
            if (curSum < min) {
                min = curSum;
            }
        }

        if (curSum < 0) return -1;
        if (min >= 0) return 0;

        for (int i  = gas.size() - 1; i >= 0; i--) {
            int rest = gas[i] - cost[i];
            min += rest;
            if (min >= 0) {
                return i;
            }
        }
        return -1;
    }
};

//贪心
class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int curSum = 0;
        int totalSum = 0;
        int start = 0;
        for (int i = 0; i < gas.size(); i++) {
            curSum += gas[i] - cost[i];
            totalSum += gas[i] - cost[i];
            if (curSum < 0) {
                start = i + 1;
                curSum = 0;
            }
        }
        if (totalSum < 0) return -1;
        return start;
    }
};

9.leetcode 135 分发糖果

//9.leetcode 135 分发糖果

class Solution {
public:
    int candy(vector<int>& ratings) {
        vector<int> result(ratings.size(), 1);

        //从前向后   右比左大
        for (int i = 1; i < ratings.size(); i++) {
            if (ratings[i] > ratings[i - 1]) result[i] = result[i - 1] + 1;
        }
        //从后向前   左比右大
        for (int i = ratings.size() - 2; i >= 0; i--) {
            if (ratings[i] > ratings[i + 1]) result[i] = max(result[i], result[i + 1] + 1);
        }
        //统计结果
        int res = 0;
        for (int i = 0; i < result.size(); i++) res += result[i];
        return res;
    }
};

10.leetcode 860 柠檬水找零

//10.leetcode 860. 柠檬水找零

class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        int five = 0, ten = 0;
        for (int bill : bills) {
            if (bill == 5) five++;

            if (bill == 10) {
                if (five <= 0) return false;
                ten++;
                five--;
            }
            if (bill == 20) {
                if (five > 0 && ten > 0) {
                    five--;
                    ten--;
                } else if (five >= 3) {
                    five -= 3;
                } else return false;
            }
        }
        return true;
    }
};

11.leetcode 406 根据身高重建队列

//11.leetcode 406.根据身高重建队列

//数组
class Solution {
public:
    static bool cmp(const vector<int> a, const vector<int> b) {
        if (a[0] == b[0]) return a[1] < b[1];
        return a[0] > b[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort(people.begin(), people.end(), cmp);
        vector<vector<int>> que;
        for (int i = 0; i < people.size(); i++) {
            int position = people[i][1];
            que.insert(que.begin() + position, people[i]);
        }
        return que;
    }
};

//链表

class Solution {
public:
    static bool cmp(const vector<int> a, const vector<int> b) {
        if (a[0] == b[0]) return a[1] < b[1];
        return a[0] > b[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort(people.begin(), people.end(), cmp);
        //list底层是链表，插入效率比vector高
        list<vector<int>> que;
        for(int i = 0; i < people.size(); i++) {
            int position = people[i][1];
            std::list<vector<int>>::iterator it = que.begin();
            while (position--) {
                it++;
            }
            que.insert(it, people[i]);
        }
        return vector<vector<int>>(que.begin(), que.end());
    }
};

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

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


class Solution {
private:
    static bool cmp(const vector<int>& a, const vector<int>& b) {
        return a[0] < b[0];
    }
public:
    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++) {
            if (points[i][0] > points[ i - 1][1]) { // 气球i与气球i - 1不相邻
                result++;
            } else {  //气球i和气球i - 1挨着
                //更新重叠气球最小右边界
                points[i][1] = min(points[i - 1][1], points[i][1]);
            }
        }
        return result;
    }
};

13.leetcode 435 无重叠区间

//13.leetcode 435. 无重叠区间


class Solution {
public:
    //按区间右边界进行排序
    static bool cmp(const vector<int>& a, const vector<int>& b) {
        return a[1] < b[1];
    }
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if (intervals.size() == 0) return 0;
        sort(intervals.begin(), intervals.end(), cmp);
        int count = 1;  //记录非交叉区间个数
        int end = intervals[0][1]; //记录区间分割点
        for (int i = 1; i < intervals.size(); i++) {
            if (end <= intervals[i][0]) {
                end = intervals[i][1];
                count++;
            }
        }
        return intervals.size() - count;
    }
};

14.leetcode 763 划分字母区间

//14.leetcode 763 划分字母区间

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, 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;
            }
        }
        return result;
    }
};

15.leetcode 56 合并区间

//15.leetcode 56. 合并区间

class Solution {
public:
    static bool cmp(const vector<int>& a, const vector<int>& b) {
        return a[0] < b[0];
    }
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        vector<vector<int>> result;
        if (intervals.size() == 0) return result;
        sort(intervals.begin(), intervals.end(), cmp);
        bool flag = false;
        int length = intervals.size();

        for (int i = 1; i < length; i++) {
            int start = intervals[i - 1][0];
            int end = intervals[i - 1][1];
            while (i < length && intervals[i][0] <= end) {
                end = max(end, intervals[i][1]);
                if (i == length - 1) flag = true;
                i++;
            }
            result.push_back({start, end});
        }
        if (flag == false) {
            result.push_back({intervals[length - 1][0], intervals[length - 1][1]});
        }
        return result;
    }
};

16.leetcode 738 单调递增的数字

//16.leetcode 738. 单调递增的数字

//暴力循环
class Solution {
private:
    bool checkNum(int num) {
        int max = 10;
        while (num) {
            int t = num % 10;
            if (max >= t) max = t;
            else return false;
            num = num / 10;
        }
        return true;
    }
public:
    int monotoneIncreasingDigits(int n) {
        for (int i = n; i > 0; i--) {
            if (checkNum(i)) return i;
        }
        return 0;
    }
};


//贪心
class Solution {
public:
    int monotoneIncreasingDigits(int n) {
        string strNum = to_string(n);
        //flag 用来标记赋值9从哪里开始
        int flag = strNum.size();
        for (int i = strNum.size() - 1; i > 0; i--) {
            if (strNum[i - 1] > strNum[i]) {
                flag = i;
                strNum[i - 1]--;
            }
        }
        for (int i = flag; i < strNum.size(); i++) {
            strNum[i] = '9';
        }
        return stoi(strNum);
    }
};

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

//17. leetcode 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;
    }
};

//动态规划

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2, 0));
        dp[0][0] -= prices[0];
        for (int i =  1; i < n; i++) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
        }
        return max(dp[n - 1][0], dp[n - 1][1]);
    }
};

18.leetcode 968 监控二叉树

//18.leetcode 968 监控二叉树

/**
 * 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 {
private:
    int result;
    int traversal(TreeNode* cur) {
        //空节点 该节点有覆盖
        if (cur == nullptr) return 2;
        int left = traversal(cur->left);
        int right = traversal(cur->right);

        //左右节点都覆盖
        if (left == 2 && right == 2) return 0;
        //left == 0 && right == 0 左右节点无覆盖
        //left == 1 && right == 0 左节点有摄像头，右节点无覆盖
        //left == 0 && right == 1 左节点无覆盖，右节点有摄像头
        //left == 0 && right == 2 左节点无覆盖 有节点覆盖
        //left == 2 && right == 0 左节点覆盖 右节点无覆盖
        if (left == 0 || right == 0) {
            result++;
            return 1;
        }

        //left == 1 && right == 2 左节点有摄像头 右节点有覆盖
        //left == 2 && right == 1 左节点有覆盖 右节点有摄像头
        //left == 1 && right == 1 左右节点有摄像头
        if (left == 1 || right == 1) return 2;

        return -1;
    }
public:
    int minCameraCover(TreeNode* root) {
        result = 0;
        if (traversal(root) == 0) {
            result++;
        }
        return result;
    }
};
EurekaZzz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode-贪心算法
a445673440的博客
11-26 502
记录，整理LeetCode中与“贪心算法”相关的题目
leetcode(贪心算法专题)
qq_46517733的博客
12-01 683
贪心算法1.导论2.编程题2.1 455. 分发饼干 1.导论 贪心的本质是选择每一阶段的局部最优，从而达到全局最优。 一般解题步骤 将问题分解为若干个子问题 找出适合的贪心策略 求解每一个子问题的最优解 将局部最优解堆叠成全局最优解 2.编程题 2.1 455. 分发饼干 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。 对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j]
LeetCode：贪心算法（30道经典题目）
一起加油~
06-10 3605
LeetCode贪心算法刷题，列了一些经典题目，附带C++和Python求解。
【LeetCode】-贪心算法
银尘博客
03-31 5720
文章目录前言一、组合二、摆动序列 前言 初识LeetCode与算法，将在此系列文章里面，记录自己的算法学习经历，前期主要是监督自己学习打卡，后期我会将自己对知识的理解，慢慢补充到文章当中，希望大家能在阅读我的文章中，有所收获。该系列文章的刷题顺序以代码随想录为线索。 一、组合 题目： 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。 对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j
LeetCode算法学习笔记——贪心算法
luoyihao123456的博客
05-08 439
遵循某种规律，不断贪心的选取当前最优的算法。 1.已知一些孩子和一些糖果，每个孩子有需求因子g，每个糖果有大小s，当某个糖果的大小s>=某个孩子的需求因子g时，代表该糖果可以满足该孩子；求使用这些糖果，最多可以满足多少孩子？ 例如g=[5,10,2,9,15,9];s=[6,1,20,3,8]。最多满足3个孩子。 分析： 尽量用最小的糖果刚好满足孩子，这样可以把较大的糖果留出来满足其他的孩子。 统计满足了的孩子个数child class Solution { pu...
《leetcode-solutions》
04-19
2. 算法基础：排序（冒泡、选择、插入、快速、归并等）、搜索（线性、二分、深度优先、广度优先等）、动态规划、贪心策略、回溯、分治等。这些基本算法是解决问题的工具，不同的问题可能需要结合不同的算法进行求解...
leetcode卡-LeetCode-Algorithm:LeetCode-算法
07-06
5. **贪心算法**：在每一步选择局部最优解，以期望达到全局最优解。 6. **回溯法**：用于在解决问题时尝试所有可能的解决方案，常用于组合问题和约束满足问题。 7. **字符串处理**：涉及到模式匹配、字符串反转、...
蓄水池算法leetcode-leetcode-js-chimy:leetcode-js-chimy
06-30
贪心算法 分支算法 动态规划算法 2.字符串 3.队列 4.链表 5.双指针 6.栈 7.堆 8。树 9.二叉搜索树 10.字典树 11.线段树 12.并查集 13.哈希表 14.图 基础算法 1.排序 2.递归 3.二分查找 4.回溯算法 5.位运算 6.分治...
leetcode题库-algorithm-leetcode:leetcode-algorithm-算法代码日常刷题
06-29
在LeetCode中，你可以找到各种语言（如Python、Java、C++等）的解题方案，这些题目按照难度和类型进行分类，包括但不限于数组、链表、字符串、栈、队列、二叉树、图、哈希表、动态规划、回溯、贪心算法等。...
蓄水池算法leetcode-leetcode-cn.go:leetcode-cn.go
06-30
贪心算法 78 广度优先搜索 74 双指针 70 栈 64 并查集 30 分治算法 28 Sliding Window 24 递归 23 字典树 18 线段树 12 Ordered Map 10 队列 10 几何 9 极小化极大 8 树状数组 6 Line Sweep 6 Random 6 拓扑排序 6 ...
Leetcode-贪心算法
能能
10-23 1757
贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。 也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。 455. 分发饼干 题目链接 思路 这道题目给了我们两组array，一组代表小朋友的胃口值，另一组代表曲奇饼干的大小。 我们要分发曲奇给尽可能多的小朋友，并且曲奇饼干的大小要满足小朋友的胃口。 所以，最好给孩子们分配与他胃口最接近的饼干。 不...
Leetcode--------贪心
qq_40128284的博客
08-25 344
455. 分发饼干 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。 对每个孩子i，都有一个胃口值g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干j，都有一个尺寸s[j]。如果s[j]>= g[i]，我们可以将这个饼干j分配给孩子i，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。 示例1: 输入: g = [1,2,3], s = [1,1] 输出: 1 解释: 你有三个孩子和两...
Leetcode学习之贪心算法
frighting_ing的博客
11-22 1420
贪心算法理论基础 题目分类大纲如下： 什么是贪心 贪心的本质是选择每一阶段的局部最优，从而达到全局最优。 这么说有点抽象，来举一个例子： 例如，有一堆钞票，你可以拿走十张，如果想达到最大的金额，你要怎么拿？ 指定每次拿最大的，最终结果就是拿走最大数额的钱。 每次拿最大的就是局部最优，最后拿走最大数额的钱就是推出全局最优。 再举一个例子如果是 有一堆盒子，你有一个背包体积为n，如何把背包尽可能装满，如果还每次选最大的盒子，就不行了。这时候就需要动态规划。动态规划的问题在下一个系列会详细讲解。 贪心的套路（什
leetCode 53.最大子数和 图解 + 贪心算法/动态规划+优化
呵呵哒!的博客
10-02 969
由于前面已经计算过包括i = 1之前的最大连续子序列和，并且将值保存在 dp[1] 里，所以count = dp[1] + (-3) = 1 + (-3) = -2，接着在count 和 nums[2] = -3中选取最大值，即。发现 count < nums[3]，这时候取最大值就可以让dp[3] = nums[3]，表示接下来，可以调整起点，让 i = 3 为起点。count = (-2) + 1 = -1,在count 和 nums[1] = 1中选取最大值，即。贪心算法的巧妙需要慢慢体会！
leetcode贪心算法题总结(一)
最新发布
m0_55283616的博客
12-27 1045
此系列分三章来记录leetcode的有关贪心算法题解，题目我都会给出具体实现代码，如果看不懂的可以后台私信我。
leetcode 经典贪心算法题目(思路、方法、code)
Ding 的博客
05-03 3808
用于回顾数据结构与算法时刷题的一些经验记录 (提出对应的贪心算法时最好自己举例子试试能否可行) 文章目录[455. 分发饼干](https://leetcode-cn.com/problems/assign-cookies/)[376. 摆动序列](https://leetcode-cn.com/problems/wiggle-subsequence/)[402. 移掉K位数字](https://...
leetcode--贪心算法
s11235218的博客
03-30 475
贪心算法 选择排序就是贪心算法的经典实现 分割平衡字符串 在一个 平衡字符串 中，‘L’ 和 ‘R’ 字符的数量是相同的。 给你一个平衡字符串 s，请你将它分割成尽可能多的平衡字符串。 注意：分割得到的每个字符串都必须是平衡字符串，且分割得到的平衡字符串是原平衡字符串的连续子串。 返回可以通过分割得到的平衡字符串的 最大数量 。 示例 1： 输入：s = “RLRRLLRLRL” 输出：4 解释：s 可以分割为 “RL”、“RRLL”、“RL”、“RL” ，每个子字符串中都包含相同数量的 ‘L’ 和 ‘
leetcode中贪心算法
07-27
在LeetCode上，有许多使用贪心算法解决的问题。 其中一道经典的贪心算法题目是"Jump Game"（跳跃游戏）。题目要求判断能否从数组的第一个元素跳到最后一个元素，每个元素的值代表可以向后跳跃的最大步数。 解决这...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值