4.17--4.19刷题记录（贪心）

第一部分：准备工作

代码随想录中解释为：贪心的本质是选择每一阶段的局部最优，从而达到全局最优。

而我的理解为：贪心实质上是具有最优子结构的一种算法。所有的解都能由当前最优的解组成。

第二部分：开始刷题

（1）455. 分发饼干 - 力扣（LeetCode）

代码思路：首先对g和s进行排序，用count记录胃口值，从前往后遍历饼干大小，如果饼干能够满足胃口，则胃口++；这时候需要注意访问超出的问题，故要加一个break判断。

class Solution {
public:int findContentChildren(vector<int>& g, vector<int>& s) {sort(g.begin(),g.end());sort(s.begin(),s.end());int count=0;for(int i=0;i<s.size();i++){//遍历每一个饼干，如果正好大于胃口，则直接赋值if(count==g.size()){break;}if(s[i]>=g[count]){count++;}}return count;}
};

（2）376. 摆动序列 - 力扣（LeetCode）

此题目有以下几个难点：

首先要记录差值，那么最初始化的时候ans=1
差值如何比较第一个和最后一个，这时候使用的是初始值0，和0进行比较
if逻辑：如果有平数据的话怎么处理：if判断条件中一边=0，另一边不等于0
更新pre和cur，每一次进行翻转的时候才进行保存

class Solution {
public:int wiggleMaxLength(vector<int>& nums) {//首先计算两个的差值，并且与前一个比较int pre=0,cur=0;int ans=1;for(int i=1;i<nums.size();i++){cur=nums[i]-nums[i-1];if(pre>=0&&cur<0||pre<=0&&cur>0){ans++;pre=cur;}}return ans;}
};

（3）53. 最大子数组和 - 力扣（LeetCode）

贪心思路：

如果count累加器比当前ans大，那么就更新。
如果为正数，那么就累加（因为后面进行累加的话可以理解为在0的基础上进行累加，正数肯定比0大）
如果为负数，那么转换为0，后面在0的基础上加。

class Solution {
public:int maxSubArray(vector<int>& nums) {int count=0,ans=nums[0];for(int i=0;i<nums.size();i++){count+=nums[i];if(count>ans){ans=count;}if(count<0){count=0;}}return ans;}
};

（4）122. 买卖股票的最佳时机 II - 力扣（LeetCode）

贪心思路：

注意题目为可以同一天进行操作，也就是说可以同一天买卖
如果后一天比前一天利润大，那么卖掉。因为如果后面有更大的，呢么可以买当前的后一个到时候再卖掉。其原理等于买现在卖后面更大的。

class Solution {
public:int maxProfit(vector<int>& prices) {int profit=0;for(int i=0;i<prices.size()-1;i++){int sub=prices[i+1]-prices[i];if(sub>0){profit+=sub;}}return profit;}
};

（5）55. 跳跃游戏 - 力扣（LeetCode）

贪心思路：

不断更新自己能去的最大值，如果能够到达队尾，那么就返回true
初始值的设定，far一开始为0，表示自己的第一步
far>=n-1，表示到达末尾元素

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

（6）45. 跳跃游戏 II - 力扣（LeetCode）

贪心思路：

确定一个区间和一个值，区间表示这个范围内可以到达的地方，值表示这个范围内的下一步能够到达的地方。

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

（7）1005. K 次取反后最大化的数组和 - 力扣（LeetCode）

贪心：将绝对值最大的进行翻转。

方法一：一次排序

class Solution {
static bool cmp(int a,int b){return abs(a)>abs(b);
}
public:int largestSumAfterKNegations(vector<int>& A, int K) {sort(A.begin(), A.end(), cmp);       // 第一步for (int i = 0; i < A.size(); i++) { // 第二步if (A[i] < 0 && K > 0) {A[i] *= -1;K--;}}if (K % 2 == 1) A[A.size() - 1] *= -1; // 第三步int result = 0;for (int a : A) result += a;        // 第四步return result;}
};

方法二：两次排序

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

（8）134. 加油站 - 力扣（LeetCode）

贪心思路：

cur_rest表示当前的剩余量，如果累加和小于零就说明从旧的start无法到达当前的i。那么新的start就要从i+1开始
total_rest表示总和，如果他小于零则表示不管从哪儿开始都无法到达终点。
所以本题用贪心的思路就是选择能够满足当前cur_rest的start，如果最后total大于等于零，那么就表示可达。（我的理解就是假如最后total=0，那么一定有一个分界点，使得后半部分的和能够填满前半部分的负数。那么就是这个start。如果总和为正数，那么就更好了。

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

（9）135. 分发糖果 - 力扣（LeetCode）

贪心策略：

一次是从左到右遍历，只比较右边孩子评分比左边大的情况。
一次是从右到左遍历，只比较左边孩子评分比右边大的情况。

class Solution {
public:int candy(vector<int>& ratings) {int n=ratings.size();vector<int>candies(n,1);int count=0;for(int i=0;i<n-1;i++){if(ratings[i]<ratings[i+1]){candies[i+1]=candies[i]+1;}}for(int i=n-1;i>0;i--){if(ratings[i]<ratings[i-1]){candies[i-1]=max(candies[i]+1,candies[i-1]);}}for(int i=0;i<n;i++){count+=candies[i];}return count;}
};

（10）860. 柠檬水找零 - 力扣（LeetCode）

贪心思路：此题比较简单，要分三种情况进行讨论

五块的：直接++
十块的：十块++，五块--
二十块的：优先十块--+五块--或者五块直接减三

class Solution {
public:bool lemonadeChange(vector<int>& bills) {int five=0,ten=0,ershi=0;for(int i=0;i<bills.size();i++){//5if(bills[i]==5){five++;}//10else if(bills[i]==10){if(five==0)return false;ten++;five--;}//20else if(bills[i]==20){//if(ten>0&&five>0){ten--;five--;ershi++;}else if(five>=3){five=five-3;ershi++;}else return false;}}return true;}
};

（11）406. 根据身高重建队列 - 力扣（LeetCode）

贪心思路：

首先明确有两个维度，分别是身高以及位置。如果保证位置有序的话，没有办法同时保证身高的有序性。那么就只能确定身高这一个维度，从而进一步确定位置
贪心的思路就是保证当前序列的有序性，那么如何保证呢？就不断取当前元素进行插入。

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>>queue;for(int i=0;i<people.size();i++){int position=people[i][1];queue.insert(queue.begin()+position,people[i]);}return queue;}
};

（12）452. 用最少数量的箭引爆气球 - 力扣（LeetCode）

贪心思路：

首先进行排序，按照每一个气球的直径的最远距离进行从小到大的排序。
贪心策略为：使用最少的针扎掉尽可能多的气球

class Solution {
public:static bool cmp(vector<int>&a,vector<int>&b){return a[1]<b[1];}int findMinArrowShots(vector<vector<int>>& points) {sort(points.begin(),points.end(),cmp);int arrow=1;int end=points[0][1];for(int i=1;i<points.size();i++){if(points[i][0]<=end){continue;}else{arrow+=1;end=points[i][1];}}return arrow;}
};

（13）435. 无重叠区间 - 力扣（LeetCode）

贪心思路：和上题思路一样，秒掉

class Solution {
public:static bool cmp(vector<int>&a,vector<int>&b){return a[1]<b[1];}int eraseOverlapIntervals(vector<vector<int>>& intervals) {sort(intervals.begin(),intervals.end(),cmp);int ans=1;int end=intervals[0][1];for(int i=1;i<intervals.size();i++){if(intervals[i][0]<end){continue;}else{ans+=1;end=intervals[i][1];}}return intervals.size()-ans;}
};

（14）763. 划分字母区间 - 力扣（LeetCode）

贪心思路：给不同的字符设置最晚出现位置，在这个区间内不不断进行扩展，如果i到达了最远位置并没有继续向前扩展，则说明这是一个区间间隔。

class Solution {
public:vector<int> partitionLabels(string s) {vector<int>ans;unordered_map<char,int>cnt;for(int i=0;i<s.size();i++){cnt[s[i]]=i;}int left=0,right=0;for(int i=0;i<s.size();i++){right=max(right,cnt[s[i]]);if(i==right){ans.push_back(right-left+1);left=right+1;}}return ans;}
};

（15）56. 合并区间 - 力扣（LeetCode）

贪心思路：整体来讲思路没有问题，只是处理最后一个vector的时候存在一些问题。以及最后ans.push_back({start,end});使用的是方括号，因为这是数组初始化的一个方式。

class Solution {
public:static bool cmp(vector<int>&a,vector<int>&b){return a[0]<b[0];}vector<vector<int>> merge(vector<vector<int>>& intervals) {vector<vector<int>>ans;sort(intervals.begin(),intervals.end(),cmp);int start=intervals[0][0],end=intervals[0][1];for(int i=1;i<intervals.size();i++){if(intervals[i][0]<=end){end=max(end,intervals[i][1]);}else{ans.push_back({start,end});start=intervals[i][0];end=intervals[i][1];}}ans.push_back({start,end});return ans;}
};

（16）738. 单调递增的数字 - 力扣（LeetCode）

贪心思路：从后往前遍历，flag记录从当前位置开始到结尾一直为0的数字

class Solution {
public:int monotoneIncreasingDigits(int n) {string num=to_string(n);int flag=num.size();for(int i=num.size()-1;i>0;i--){if(num[i]<num[i-1]){flag=i;//不是flag--num[i-1]--;}}for (int i = flag; i < num.size(); i++) {num[i] = '9';}return stoi(num);}
};

（17）968. 监控二叉树 - 力扣（LeetCode）

贪心思路：

节点一共有三种性质：第一种性质：未覆盖0；第二种性质：已覆盖2；第三种性质：装摄像头1
情况一共分为九种，00->1,01->1,02->1,10->1,11->2,12->2,20->1,21->2,22->0
进行分类可得：
第一类（根节点返回0）：22->0，只有一种情况，当左右两个节点都已经被当前节点的下层所监控到，根节点表示未被监控到
第二类（根节点装摄像头，返回1）：00->1,01->1,02->1,10->1,20->1，有五种情况，只要左子树或右子树里面有一个0，未被覆盖到就可以
第三类（根节点被监控到，返回2）：11->2,12->2,21->2，有三种情况，只要左子树或者右子树有一个1，并且都没有零即可

class Solution {
public:int ans=0;int dfs(TreeNode *root){if(root==nullptr)return 2;int left=dfs(root->left);int right=dfs(root->right);if(left==0||right==0){ans++;return 1;}else if(left==1||right==1){return 2;}else if(left==2&&right==2){return 0;}//其实根本不会遍历到以下这个东西，所有情况都已经被包含在if中return 2;}int minCameraCover(TreeNode* root) {if(dfs(root)==0)ans++;return ans;}
};