贪心算法经典题目：https://blog.csdn.net/qq_42820853/article/details/106788590
给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。
示例 1:
输入: [2,3,1,1,4] 输出: true 解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
示例 2:
输入: [3,2,1,0,4] 输出: false 解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。
思路：通过题目中的跳跃规则，最多能跳多远?如果能够越过最后一格，返回 true，否则返回 false。
class Solution {
public:
bool canJump(vector<int>& nums) {
int len = nums.size();
int dis = 0;
for(int i=0;i<len-1;i++){
dis = max(dis,nums[i]+i);
if(dis<=i){
return false;
}
}
return dis>=len-1;
}
};
给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
你的目标是使用最少的跳跃次数到达数组的最后一个位置。
示例:
输入: [2,3,1,1,4] 输出: 2 解释: 跳到最后一个位置的最小跳跃数是2。 从下标为 0 跳到下标为 1 的位置，跳1步，然后跳3步到达数组的最后一个位置。
说明:
假设你总是可以到达数组的最后一个位置。
class Solution {
public:
int jump(vector<int>& nums) {
int len = nums.size();
int dis = 0;
int end = 0;
int step = 0;
for(int i=0;i<len-1;i++){
dis = max(dis,nums[i]+i);
if(end==i){
step++;
end = dis;
}
}
return step;
}
};
假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 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:
int findContentChildren(vector<int>& g, vector<int>& s) {
int num = 0;
sort(g.begin(),g.end());
sort(s.begin(),s.end());
int j = 0;
int i = 0;
for(;i<s.size()&&j<g.size();i++){
if(s[i]>=g[j]){
num++;
j++;
}
}
return num;
}
};
135. 分发糖果
老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。
你需要按照以下要求，帮助老师给这些孩子分发糖果：
每个孩子至少分配到 1 个糖果。
相邻的孩子中，评分高的孩子必须获得更多的糖果。
那么这样下来，老师至少需要准备多少颗糖果呢？
示例 1:
输入: [1,0,2]
输出: 5
解释: 你可以分别给这三个孩子分发 2、1、2 颗糖果。
示例 2:
输入: [1,2,2]
输出: 4
解释: 你可以分别给这三个孩子分发 1、2、1 颗糖果。
第三个孩子只得到 1 颗糖果，这已满足上述两个条件。
思路：
在处理这道题的时候，不能只单纯的判断数字是否有递增；
在评分处于递增，但中间有递减，再次递增的情况时，要注意再次递减时候糖果的分配
评分: 1 2 3 3 4 5 4 3 4 5 6 7 6 5
糖果: 1 1 1 1 1 1 1 1 1 1 1 1 1 1 //每个小孩最少要拿到一个糖果
过程: 1 2 3 1 2 3 1 1 2 3 4 5 1 1 //后一个小朋友大于前一个时，要多拿一个糖果
———— ————
//5 4 //6 5 糖果分配不合理
//所以要从后向前再进行一次遍历，保证处于递减情况时，糖果分配的合理性
//糖果分配的第一个过程：if(ratings[i] > ratings[i-1]) 糖果比前一个多拿一个
//从后向前再次进行遍历时: nums[i] = max(nums[i],nums[i+1]+1);
//i的评分高于i+1，所以糖果一定要取最多的
class Solution {
public:
int candy(vector<int>& ratings) {
int len = ratings.size();
if(len == 0 || len == 1) return len;
int candy = 0;
vector<int> nums(len,1);
for(int i = 1;i < len;++i)
{
if(ratings[i] > ratings[i-1]) //比前一个评分高的情况
{
nums[i] = nums[i-1] + 1;
}
}
for(int i = len-2;i >= 0;--i) //比后一个评分高，但是分的糖果少的情况
{
if(ratings[i] > ratings[i+1])
{
nums[i] = max(nums[i],nums[i+1]+1);
}
}
for(int i = 0;i < nums.size();++i)
{
candy += nums[i];
}
return candy;
}
};
134. 加油站
在一条环路上有 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 升汽油。
因此，无论怎样，你都不可能绕环路行驶一周。
思路1:暴力解法，两层循环判断，第一层选择初始站点，第二层判断是不是满足
时间复杂度 (N^2)
class Solution {
public:
int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
//看输入数据是否合理，边界情况判定
if(gas.size()==0||gas.size()!=cost.size())return -1;
//计算消耗的油和能提供的油
int temp1 = accumulate(gas.begin(), gas.end(), 0);
int temp2 = accumulate(cost.begin(), cost.end(), 0);
//若消耗的小于或等于提供的，那么一定有一个起点可以，否则输出-1
if (temp1 < temp2) return -1;
int l= gas.size();
if (l == 1) return 0;
//初始化，从第一个站点开始遍历看是否满足
int start = 0;
int cur = 1;
int oil = gas[0] - cost[0];
//因为已经证明了肯定有一个加油站可以作为起点
//依次遍历每个加油站，找到满足条件的那个
while (cur != start&&start<l) {
if (oil >=0) {
oil += gas[cur] - cost[cur];
cur = (cur + 1) % l;
} else {
start++;
cur=start+1;
cur=cur%l;
oil= gas[start] - cost[start];
}
}
return start;
}
};
思路2: 从i到j位置,有 sum(gas) < sum(cost),说明i到不了j,并且i到j之间任何一个位置都到不了j
时间复杂度：O(N) ， 这是因为只有一个遍历了所有加油站一次的循环。
空间复杂度： O(1) ，因为此算法只使用了常数个变量。
官方解法：
class Solution {
public:
int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
int n = gas.size();
int total_tank = 0;
int curr_tank = 0;
int starting_station = 0;
for (int i = 0; i < n; ++i) {
total_tank += gas[i] - cost[i];
curr_tank += gas[i] - cost[i];
// If one couldn't get here,
if (curr_tank < 0) {
// Pick up the next station as the starting one.
starting_station = i + 1;
// Start with an empty tank.
curr_tank = 0;
}
}
return total_tank >= 0 ? starting_station : -1;
}
};
给定一个以字符串表示的非负整数 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) {
if (k == num.size())
return "0";
while (k){
int i;
bool flag = false;
//遍历查找有没有前一个数大于后一个数的情况
for (i = 0; i < num.size() - 1; i++){
if (num[i] > num[i+1]){
num.erase(num.begin() + i);
flag = true;
k--;
break;
}
}
//遍历完数组，而没有删除元素，说明字符串有序，直接删除后K个
if (i == num.size() - 1 && !flag){
num.erase(num.end()-k,num.end());
break;
}
}
while (num[0] == '0' && num.size() > 1)
num.erase(num.begin());
if (num.empty())
return "0";
return num;
}
};
316. 去除重复字母
给你一个字符串 s ，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证 返回结果的字典序最小（要求不能打乱其他字符的相对位置）。
注意：该题与 1081 https://leetcode-cn.com/problems/smallest-subsequence-of-distinct-characters 相同
示例 1：
输入：s = "bcabc"
输出："abc"
示例 2：
输入：s = "cbacdcbc"
输出："acdb"
思路：
贪心思路：如果当前字符的左边字符比当前字符大，而且左边字符在当前字符的右边还会出现，那就先舍弃掉左边字符。
class Solution {
public:
string res = "0";//先加一个0是为了方便判断，类似链表的哑节点
string removeDuplicateLetters(string s) {
int count[26] = {0};//计数器，记录每个字母出现的次数
int visited[26] = {0};//用来记录结果数组里面是否已经包含某个字符，避免重复
for(int i = 0; i < s.size(); ++i) ++count[s[i] - 'a'];
for(const auto &c : s){
--count[c - 'a'];
if(visited[c - 'a'] == 1) continue;//已经包含了
//关键代码：如果当前字符的左边字符比当前字符大，而且左边字符在当前字符的右边还会出现，那就先舍弃掉左边字符
while(c < res.back() && count[res.back() - 'a']){
visited[res.back() - 'a'] = 0;//pop出去就不再包含了
res.pop_back();
}
res += c;
visited[c - 'a'] = 1;//包含了该字符
}
return res.substr(1);
}
};
不加0其实也差不多：
class Solution {
public:
string res;
string removeDuplicateLetters(string s) {
int count[26] = {0};//计数器，记录每个字母出现的次数
int visited[26] = {0};//用来记录结果数组里面是否已经包含某个字符，避免重复
for(int i = 0; i < s.size(); ++i) ++count[s[i] - 'a'];
for(const auto &c : s){
--count[c - 'a'];
if(visited[c - 'a'] == 1) continue;//已经包含了
while(!res.empty() && c < res.back() && count[res.back() - 'a']){
visited[res.back() - 'a'] = 0;//pop出去就不再包含了
res.pop_back();
}
res += c;
visited[c - 'a'] = 1;//包含了该字符
}
return res;
}
};