贪心算法专题

LeetCode 860. Lemonade Change

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。

顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。

每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。

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

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

示例 1：

输入：[5,5,5,10,20]
输出：true
解释：
前 3 位顾客那里，我们按顺序收取 3 张 5 美元的钞票。
第 4 位顾客那里，我们收取一张 10 美元的钞票，并返还 5 美元。
第 5 位顾客那里，我们找还一张 10 美元的钞票和一张 5 美元的钞票。
由于所有客户都得到了正确的找零，所以我们输出 true。

示例 2：

输入：[5,5,10]
输出：true

示例 3：

输入：[10,10]
输出：false

示例 4：

输入：[5,5,10,10,20]
输出：false
解释：
前 2 位顾客那里，我们按顺序收取 2 张 5 美元的钞票。
对于接下来的 2 位顾客，我们收取一张 10 美元的钞票，然后返还 5 美元。
对于最后一位顾客，我们无法退回 15 美元，因为我们现在只有两张 10 美元的钞票。
由于不是每位顾客都得到了正确的找零，所以答案是 false。

提示：
1.0 <= bills.length <= 10000
2.bills[i] 不是 5 就是 10 或是 20

class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        int fives = 0, tens = 0;
        for(auto b : bills)
        {
            if(b == 5) fives++;
            else if(b == 10)
            {
                if(fives) fives --;
                else return false;
                tens ++;
            }
            else
            {
                int t = 15;
                if(tens)
                {
                    t -= 10;
                    tens --;
                }
                while(t && fives)
                {
                    t -= 5;
                    fives --;
                }
                if(t) return false;
            }
        }
        return true;
    }
};

LeetCode 392. Is Subsequence

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长（长度 ~= 500,000），而 s 是个短字符串（长度 <=100）。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

示例 1:
s = “abc”, t = “ahbgdc”

返回 true.

示例 2:
s = “axc”, t = “ahbgdc”

返回 false.

后续挑战 :

如果有大量输入的 S，称作S1, S2, … , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

class Solution {
public:
    /*
    子序列 不需要连续
    子串 需要连续
    考虑扫描t串 最多可以匹配s多少个字母
    */
    bool isSubsequence(string s, string t) {
        int k = 0;//当前匹配到哪个位置
        for(int i = 0; i < t.size() && k < s.size(); i++)
            if(t[i] == s[k])
                k++;//s的当前位匹配到了 循环下一次
        return k == s.size(); //k等于s的大小 说明匹配成功
    }
};

LeetCode 455. Assign Cookies

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 i ，都有一个胃口值 gi ，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j ，都有一个尺寸 sj 。如果 sj >= gi ，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

注意：

你可以假设胃口值为正。
一个小朋友最多只能拥有一块饼干。

示例 1:

输入: [1,2,3], [1,1]

输出: 1

解释:
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。

示例 2:

输入: [1,2], [1,2,3]

输出: 2

解释:
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.

class Solution {
public:
    /*
    (贪心) O(nlogn)
    1.分别将孩子的贪心指数和饼干尺寸都从小到大排序。
    2.定义 i和 j 从0开始，代表尝试将第 j 块饼干分配给第 i 个孩子。若 sj>=gi，则答案加1，i和j都向后移动；否则 j 向后移动。
    */
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int i = 0, ans = 0;
        for(int j = 0; j < s.size() && i < g.size(); j++)
            if(s[j] >= g[i])
            {
                i ++;
                ans ++;
            }
        return ans;
    }
};

LeetCode 55. Jump Game

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

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

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

示例 1:

输入: [2,3,1,1,4]
输出: true
解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。

示例 2:

输入: [3,2,1,0,4]
输出: false
解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int dist = 0;//扫描数组，记录数组里面可以跳的最远的距离
        for(int i = 0; i < nums.size() && i <= dist; i++)
            dist = max(dist, nums[i] + i); //当前格可以跳的位置 + 当前位置
        return dist >= nums.size() - 1;
    }
};

LeetCode 45. Jump Game II

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

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

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

示例:

输入: [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

说明:

假设你总是可以到达数组的最后一个位置。

class Solution {
public:
    /*
    (动态规划，贪心优化) O(n)
    f[i]表示到达i所需要的最少步数。
    */
    int jump(vector<int>& nums) {
        if(nums.size() == 1) return 0;
        int l = 0, r = 0, step = 0;
        while(l <= r)
        {
            int max_r = 0;
            for(int i = l; i <= r; i++)
                max_r = max(max_r, nums[i] + i);
            l = r + 1, r = max_r;
            step ++;
            if(r >= (int)nums.size() - 1) break;//vector.size()是一个无符号的变量 强转int 
        }
        return step;
    }
};

class Solution {
public:
    /*
    (动态规划，贪心优化) O(n)
    f[i]表示到达i所需要的最少步数。
    */
    int jump(vector<int>& nums) {
        int n = nums.size();
        vector<int> f(n);
        f[0] = 0;
        int last = 0;
        for(int i = 1; i < n; i++)
        {
            while(i > last + nums[last])
                last++;
            f[i] = f[last] + 1;
        }
        return f[n - 1];        
    }
};

LeetCode 376. Wiggle Subsequence

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

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

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

示例 1:

输入: [1,7,4,9,2,5]
输出: 6
解释: 整个序列均为摆动序列。

示例 2:

输入: [1,17,5,10,13,15,10,5,16,8]
输出: 7
解释: 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。

示例 3:

输入: [1,2,3,4,5,6,7,8,9]
输出: 2

进阶:
你能否用 O(n) 时间复杂度完成此题?

class Solution {
public:
    /*
    对nums进行相邻去重，即用stl中的unique函数去除容器中相邻的重复元素（注意它是把重复元素放在容器末尾，返回值为去重之后的尾地址），再用erase函数进行删除
    */
    int wiggleMaxLength(vector<int>& nums) {
        nums.erase(unique(nums.begin(), nums.end()), nums.end());
        
        if(nums.size() <= 2) return nums.size();
        
        int res = 2;
        for(int i = 1; i + 1 < nums.size(); i++)
        {
            int a = nums[i - 1], b = nums[i], c = nums[i + 1];
            if(a < b && b > c) res ++;
            else if(a > b && b < c) res ++;
        }
        return res;
    }
};

LeetCode 406. Queue Reconstruction by Height

假设有打乱顺序的一群人站成一个队列。 每个人由一个整数对(h, k)表示，其中h是这个人的身高，k是排在这个人前面且身高大于或等于h的人数。 编写一个算法来重建这个队列。

注意：
总人数少于1100人。

示例

输入:
[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]

输出:
[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]

bool cmp(vector<int>a, vector<int>b)
{
    return a[0] > b[0] || a[0] == b[0] && a[1] < b[1];
}

class Solution {
public:
    /*
    先按身高从大到小排 身高一样 按k从小到大排
    */
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort(people.begin(), people.end(), cmp);
        
        vector<vector<int>> res;
        
        for(auto p : people) res.insert(res.begin() + p[1], p);
        
        return res;
    }
};

LeetCode 452. Minimum Number of Arrows to Burst Balloons

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

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

Example:

输入:
[[10,16], [2,8], [1,6], [7,12]]

输出:
2

解释:
对于该样例，我们可以在x = 6（射爆[2,8],[1,6]两个气球）和 x = 11（射爆另外两个气球）。

bool cmp(vector<int>a, vector<int>b)
{
    return a[1] < b[1];
}

class Solution {
public:
    /*
    1.首先把所有区间按照右端点从小到大排序
    2.从左到右遍历区间(贪心选择每个区间最右边的点)
    */
    int findMinArrowShots(vector<vector<int>>& points) {
        sort(points.begin(), points.end(), cmp);
        
        int res = 0, r = INT_MIN;
        
        if(points.size() >= 1 && points[0][0] == INT_MIN) res ++;
        
        for(auto p : points)
        {
            if(p[0] > r)
            {
                r = p[1];
                res ++;
            }
        }
        return res;
    }
};

LeetCode 402. Remove K Digits

给定一个以字符串表示的非负整数 num，移除这个数中的 k 位数字，使得剩下的数字最小。

注意:

num 的长度小于 10002 且 ≥ k。
num 不会包含任何前导零。

示例 1 :

输入: num = “1432219”, k = 3
输出: “1219”
解释: 移除掉三个数字 4, 3, 和 2 形成一个新的最小的数字 1219。

示例 2 :

输入: num = “10200”, k = 1
输出: “200”
解释: 移掉首位的 1 剩下的数字为 200. 注意输出不能有任何前导零。

示例 3 :

输入: num = “10”, k = 2
输出: “0”
解释: 从原数字移除所有的数字，剩余为空就是0。

class Solution {
public:
    string removeKdigits(string num, int k) {
        string res;
        for(char c : num)
        {
            while(res.size() && res.back() > c && k) //为元素大于后面 有逆序对 去掉元素
            {
                res.pop_back();
                k --;
            }
            res += c;
        }
        while(k --) res.pop_back(); //还有k 直接弹出
        
        int i = 0; //去掉前导零
        while(i < res.size() && res[i] == '0') i ++;
        if(i == res.size()) return "0";
        return res.substr(i); //去掉前i位0
    }
};

LeetCode 134. Gas Station

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

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

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

说明:

如果题目有解，该答案即为唯一答案。
输入数组均为非空数组，且长度相同。
输入数组中的元素均为非负数。

示例 1:

输入:
gas = [1,2,3,4,5]
cost = [3,4,5,1,2]

输出: 3

解释:
从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油
开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油
开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油
开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油
开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。
因此，3 可为起始索引。

示例 2:

输入:
gas = [2,3,4]
cost = [3,4,3]

输出: -1

解释:
你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。
我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油
开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油
开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油
你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
因此，无论怎样，你都不可能绕环路行驶一周。

class Solution {
public:
    //暴力
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int n = gas.size();
        for(int i = 0, j; i < n; i++)
        {
            int gas_left = 0;//剩余油量
            for(j = 0; j < n; j++)
            {
                int k = (i + j) % n;//当前位置
                gas_left += gas[k] - cost[k];
                if(gas_left < 0) break;
            }
            if(j >= n) return i;//成功 返回起点 
        }
        return -1;
    }
};

class Solution {
public:
    //暴力
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int n = gas.size();
        for(int i = 0, j; i < n; i += j + 1) //优化i += j + 1
        {
            int gas_left = 0;//剩余油量
            for(j = 0; j < n; j++)
            {
                int k = (i + j) % n;//当前位置
                gas_left += gas[k] - cost[k];
                if(gas_left < 0) break;
            }
            if(j >= n) return i; //成功 返回起点 
        }
        return -1;
    }
};