举个例子：有1元、5元、20元、100元、200元的钞票无穷多张。现使用这些钞票支付X元，最少需要多少张？
直觉告诉我们：尽可能的使用面值较大的钞票！
当前最优解即为全局最优解时，贪心成立！！
贪心法：遵循某种规律，不断贪心的选区当前最优策略的算法设计方法。
455. 分发饼干
假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 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.
思考：
1.对需求因子和糖果大小排序后观察，当某个孩子可以被多个糖果满足时，是否需要优先用某个糖果满足这个孩子？
2.当某个糖果可以满足多个孩子时，是否优先满足某个孩子？
**核心目标：**让更多孩子得到满足！
贪心规律：
1.某个糖果不能满足某个孩子，那么该糖果一定不能满足需求因子更大的孩子。
2.某个孩子可以用更小的糖果满足，没必要用更大的糖果满足，因为可以保留更大的糖果满足需求因子更大的孩子。（贪心！）
3.孩子的需需求因子更小则其更容易被满足，故优先从需求因子小的孩子尝试，可以得到正确的结果。
class Solution {
public:
int findContentChildren(vector<int>& g, vector<int>& s) {
sort(g.begin(),g.end());//胃口
sort(s.begin(),s.end());//尺寸
int child=0;
int cookie=0;
while(cookie<s.size()&&child<g.size())
{
if(g[child]<=s[cookie])
{
child++;
}
cookie++;
}
return child;
}
};
376. 摆动序列
如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。
例如， [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:
int wiggleMaxLength(vector<int>& nums) {
if(nums.size()<2)//序列个数小于2直接为摇摆序列
return nums.size();
//状态机定义
static const int BEGIN=0;
static const int UP=1;
static const int DOWN=2;
int STATE=BEGIN;
int max_len=1;//摇摆序列最大长度至少为1
int nums_sz=nums.size();
for(int i=1;i<nums_sz;i++)
{
switch(STATE)
{
case BEGIN:
if(nums[i]>nums[i-1]){
STATE=UP;
max_len++;
}
else if(nums[i]<nums[i-1]){
STATE=DOWN;
max_len++;
}
break;
case UP:
if(nums[i]<nums[i-1]){
STATE=DOWN;
max_len++;
}
break;
case DOWN:
if(nums[i]>nums[i-1]){
STATE=UP;
max_len++;
}
break;
}
}
return max_len;
}
};
402. 移掉K位数字
给定一个以字符串表示的非负整数 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。
1.当所有数字都扫描完成后，k仍然>0，应该做怎样的处理？
2.当数字中有0出现时，应该有怎样的特殊处理？
例如num=100200,k=1时。
3.如何将最后结果存储为字符串并且返回？
class Solution {
public:
string removeKdigits(string num, int k) {
vector<int> S;//把vector当作栈，因为可以遍历
string res="";//保存最终结果的字符串
int num_len=num.length();
for(int i=0;i<num_len;i++)
{
int number=num[i]-'0';
while(S.size()!=0&&number<S[S.size()-1]&&k>0)
{
S.pop_back();
k--;
}
if(S.size()!=0||number!=0)
S.push_back(number);
}
while(S.size()!=0&&k>0)//剩下的序列都是递增的
{
S.pop_back();
k--;
}
for(int i=0;i<S.size();i++)
{
res.append(1,'0'+S[i]);
}
if(res=="")
res="0";
return res;
}
};
55. 跳跃游戏
给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。
示例 1:
输入: [2,3,1,1,4]
输出: true
解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。
示例 2:
输入: [3,2,1,0,4]
输出: false
解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。
我的思路：
从最后一个位置开始遍历，出现0之后，设该位置为i，判断是否step[i-1]>1,step[i-2]>2,…直到出现另外一个step[i-m]=0，重新开始新一轮判断，若之前一轮所有判断都不成立，那么直接得出结论，不能，若都成立继续判断，直到第一个位置。
另外一个思路：
class Solution {
public:
bool canJump(vector<int>& nums) {
vector<int> index;
for(int i=0;i<nums.size();i++)
{
index.push_back(nums[i]+i);
}
int jump=0;
int max_index=index[0];
while(jump<nums.size()&&jump<=max_index)
{
max_index=max(max_index,index[jump]);
jump++;
}
if(jump==nums.size())
return true;
return false;
}
};
45. 跳跃游戏 II
给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
你的目标是使用最少的跳跃次数到达数组的最后一个位置。
示例:
输入: [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
思考：
何时跳跃才是最合适的？
贪心规律：在到达某点之前若一直不能跳跃，发现从该点不能跳到更远的地方了，在这之前肯定有次必要的跳跃！
结论：在无法到达更远的地方时，在这之前应该跳到一个可以到达更远位置的位置！
class Solution {
public:
int jump(vector<int>& nums) {
if(nums.size()<2)
return 0;
int current_max_index=nums[0];//当前可达到的最远位置
int pre_max_max_index=nums[0];//遍历各个位置过程中，可达到的最远位置
int jump_min=1;
for(int i=1;i<nums.size();i++)
{
if(i>current_max_index)//若无法向前移动了，才进行跳跃（即超出当前位置可达的最远位置）
{
jump_min++;
current_max_index=pre_max_max_index;
}
if(pre_max_max_index<nums[i]+i)
{
pre_max_max_index=nums[i]+i;
}
}
return jump_min;
}
};
452. 用最少数量的箭引爆气球
在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以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（射爆另外两个气球）。
贪心规律：
1.对于某个气球，至少需要1个弓箭将其击穿。
2.在击穿这个气球的同时，尽可能将其他气球击穿。（贪心）
bool cmp(const pair<int,int>&a,const pair<int,int>&b)
{
return a.first<b.first;
}
class Solution {
public:
int findMinArrowShots(vector<pair<int, int>>& points) {
if(points.size()==0)
return 0;
sort(points.begin(),points.end(),cmp);//对左端点进行排序
int shoot_num=1;//弓箭手的数量
int shoot_begin=points[0].first;
int shoot_end=points[0].second;
for(int i=1;i<points.size();++i)
{
if(points[i].first<=shoot_end)//气球的开始点仍在区间[begin,end]内
{
shoot_begin=points[i].first;
if(shoot_end>points[i].second)
{
shoot_end=points[i].second;
}
}else{
shoot_num++;
shoot_begin=points[i].first;
shoot_end=points[i].second;
}
}
return shoot_num;
}
};
871. 最低加油次数
汽车从起点出发驶向目的地，该目的地位于出发位置东面 target 英里处。
沿途有加油站，每个 station[i] 代表一个加油站，它位于出发位置东面 station[i][0] 英里处，并且有 station[i][1] 升汽油。
假设汽车油箱的容量是无限的，其中最初有 startFuel 升燃料。它每行驶 1 英里就会用掉 1 升汽油。
当汽车到达加油站时，它可能停下来加油，将所有汽油从加油站转移到汽车中。
为了到达目的地，汽车所必要的最低加油次数是多少？如果无法到达目的地，则返回 -1 。
注意：如果汽车到达加油站时剩余燃料为 0，它仍然可以在那里加油。如果汽车到达目的地时剩余燃料为 0，仍然认为它已经到达目的地。
示例 1：
输入：target = 1, startFuel = 1, stations = []
输出：0
解释：我们可以在不加油的情况下到达目的地。
示例 2：
输入：target = 100, startFuel = 1, stations = [[10,100]]
输出：-1
解释：我们无法抵达目的地，甚至无法到达第一个加油站。
示例 3：
输入：target = 100, startFuel = 10, stations = [[10,60],[20,30],[30,30],[60,40]]
输出：2
解释：
我们出发时有 10 升燃料。
我们开车来到距起点 10 英里处的加油站，消耗 10 升燃料。将汽油从 0 升加到 60 升。
然后，我们从 10 英里处的加油站开到 60 英里处的加油站（消耗 50 升燃料），
并将汽油从 10 升加到 50 升。然后我们开车抵达目的地。
我们沿途在1两个加油站停靠，所以返回 2 。
贪心规律：
何时加油最合适？
油用光的时候加油最合适！
在哪个加油站加油最合适？
在油量最多的加油站加油最合适！最大堆！
先尝试，把油用光，若不能到达下一个加油站，则从之前的没有加油的加油站给自己加油。
class Solution {
public:
int minRefuelStops(int target, int startFuel, vector<vector<int>>& stations) {
int res=0;//记录加过几次油
if(stations.size()<=0)
{
return target>startFuel?-1:0;
}
priority_queue<int> Q;//存储油量的最大堆
//stations.push_back(vector<int>(2,0));//将终点作为一个停靠点
vector<int> end = { 0,0 };
stations.push_back(end);
sort(stations.begin(), stations.end(), std::less<std::vector<int>>());//将停靠点至终点距离从大到小排序
vector<int> dist;
dist.push_back(0);
for (int i = 1; i < stations.size(); i++)
{
dist.push_back(stations[i][0] - stations[i-1][0]);
}
for (int i = 0; i < stations.size(); i++)
{
//int dist=target-stations[i][0];
while (!Q.empty() && startFuel < dist[i])
{
startFuel += Q.top();
Q.pop();
res++;
}
if (Q.empty() && startFuel < dist[i])
return -1;
startFuel -= dist[i];
target -= dist[i];
Q.push(stations[i][1]);
}
if (target == 0)
return res;
else {
while (!Q.empty() && startFuel < target)
{
startFuel += Q.top();
Q.pop();
res++;
}
if (startFuel < target)
return -1;
return res;
}
}
};
456
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
