贪心算法二
点赞 👍👍收藏 🌟🌟关注 💖💖
你的支持是对我最大的鼓励，我们一起努力吧!😃😃
1.最长递增子序列
题目链接： 300. 最长递增子序列
题目分析：
听懂这道题一定要把动态规划里面这道题解法搞清楚，我们的贪心策略其实是基于动态规划的解法，就是动态规划的解法的过程中发现可以用贪心优化的地方。还有优选算法那里的二分查找搞清楚。我们这里的贪心策略是要用这两个东西。
算法原理：
- 回顾 dp 的解法
状态表示：dp[i] 表示：以 i 位置的元素为结尾的所有子序列中， 最长递增子序列的长度
状态转移方程：dp[i] = max(dp[j] + 1) (j < i && nums[j] < nums[i])
更新dp[i] 的值，就是拿着nums[i] 去前面找，当找到一个位置发现这个位置的值，nums[j] < nums[i] 说明 i 可以拼在 j 的后面，此时就用这个dp[j]也就是以 j 位置为结尾的最长递增子序列的长度 然后 + 1 更新 dp[i] 的值。当把前面都找完此时dp[i]的值就是以 i 位置的元素为结尾的所有子序列中， 最长递增子序列的长度。
最核心的操作中，我们会发现一个性质：我们在考虑最长递增子序列的 "长度" 的时候，并不关心你这个序列长什么样子，我们仅关心你的 "最后一个元素" 是谁。
- 贪心优化
接下来我们用一个例子模拟一下贪心过程
从前到后扫描每一个元素，当扫描第一个位置的元素时候其实我们得到一个长度为1 的序列长什么样子。(但是我们只关心递增子序列长度为x中最后一个元素，并不关心序列长什么样子)，这一点在上面已经说过了。
扫描到3的时候发现，3是接不到7后面，所以3这个元素单独形成一个长度为1的序列，现在又找到一个长度为1的序列最后一个元素是3。此时贪心策略就来了，当我发现长度为1递增子序列有两个的时候，较大的就没有必要存了。
原因就是，所有能接到7后面的数，铁定能接到3这个数的后面，所以我们不需要存较大的7，仅需存较小的3就可以判断后面的数是否能拼到长度为1的序列后面。
这里就是我们的第一个贪心策略，存最后一个元素的时候，仅需存储最小值。
扫描8的时候，此时第二个贪心策略来了。我们其实有两种策略，第一种让8单独形成一个长度为1的序列，第二种要么让8拼到3的后面形成一个长度为2的序列。此时我们贪心选择第二种策略。因为要找最长递增子序列。
扫描到4，发现4能放到长度为1的3后面，但是不放，太浪费了，所以往下放，发现4可以自己形成一个长度为2，但是发现4小于8，所以贪心把8干掉，把4放好。
上面的过程就是，发现4能放到长度为1的3后面，但是不放。往下放，发现4能不能放到8后面，就把4放到这里，同时利用第二个贪心策略只存最小值的时候，把8干掉，4留下。
扫描到7，也是一样，7能拼到3后面就不放，7能拼到4后面也不放，所以7形成一个长度为3的序列
扫描到2，发现2拼不到3后面，只能把2放到长度为1，但是2比3小，能拼接到3后面一定能拼接到2后面，所以3干掉，保留2
扫描到14，发现能拼接到2，4，7后面但是都不放，所以14单独形成一个长度为4的序列
扫描到13，发现能拼接到2，4，7后面但是不放，不能放14后面，就放14后面，同时13比14小，14干掉，13保留
当整个数组扫描完，我们发现长度仅从1更新到4，所以最长递增子序列的长度就是4。
虽然这里拼接的序列并不是最终的序列，但是能统计到4，就是我们的最长递增子序列的长度。
这里我们总结一下贪心策略：
我们的贪心策略就体现在两个地方：存什么，存哪里
这里的贪心策略的提出就是交换论证法的思想，比如能拼接7的后面的数，铁定能拼接到3的后面，这不就是交换论证吗。
这里已经说明为什么贪心策略是对的，但是我们分析一下贪心的时间复杂度，存什么肯定是拿一个数组去存，下标为0存长度为1的最小值、下标为1存长度为2的最小值...，最耗时的就是存哪里，如果是来了一个数从前往后扫描比较时间复杂度是O(n)，那整体时间复杂度还是O(N^2)，这个好像和动规是一样的。那还贪心什么呢？比动规还难理解。
我们还可以发现，我们贪心得到的数组，其实还有优化的地方
- 利用二分优化
我们发现存长度为x的最小值数组里面的值是递增有序的。此时我们在找存哪里插入位置的时候，可以用二分快速找到插入位置。
假设来一个x，我们要找的是所有大于等于x的最小值，右边都是大于等于x，左边是小于x，这就有了二段性。就可以用二分查找了。
证明数组是递增的。
直接证明：
第一个元素来了直接就是一个点，第二个元素来发现能拼在第一个元素后面所以重新开一个点，如果不能放就把这个元素覆盖到原始元素，这里有个不等关系，这个元素大于前一个元素，小于后一个元素。递增是不会改变的。
回归一下二分，定义一个left，right，mid，如果mid落在左边 left = mid + 1，如果mid落在右边有可能是结果 right = mid，等到循环解决，left或者right就是要插入的位置。
这里有个细节问题，再用二分的时候要考虑边界情况，因为我们要找的是大于等于nums[i]的最小值的位置，left和right其实是在这个数组中找，有没有这个数比这个数组中所有数都大，那此时应该是数组重新开一个空间，放在这个新开位置里，所以二分之前先判断 nums[i] > ret.back()，此时不用二分，直接放在数组后一个位置。否则在二分寻找插入位置。
cpp
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
int n = nums.size();
vector<int> ret;
ret.push_back(nums[0]);
for(int i = 1; i < nums.size(); ++i)
{
if(nums[i] > ret.back()) // 如果能接在最后⼀个元素后⾯，直接放
ret.push_back(nums[i]);
else
{
// 二分插入位置
int left = 0, right = ret.size() - 1;
while(left < right)
{
int mid = (left + right) / 2;
if(ret[mid] < nums[i])
left = mid + 1;
else
right = mid;
}
ret[left] = nums[i];
}
}
return ret.size();
}
};2.递增的三元子序列
题目链接： 334. 递增的三元子序列
题目分析：
上面是要找到最长的递增子序列，这里仅需判断一下是否存在长度为3的递增子序列就可以了。
算法原理：
最长递增子序列有两种解法，这里也是有两种解法。
解法一：动规
利用 dp 找到数组中最长递增子序列的长度，判断是否大于等于 3 即可
时间复杂度 O(n^2)，会超时的。
解法二：贪心
因为这里我们仅需判断递增子序列长度是否等于3就可以了，因此可以不用二分也是非常快的。我们只要判断长度3这里是否有值就可以了，不需要关心里面是否最小也不需要关心长度4、5、6...的情况。任意来一个x，我们仅需要比较2次，最差每个数都比较2次，总体就是2n，时间复杂度就是O(n)，即使用二分也是O(log~2~n)，差别不是很大。
那如何实现呢？
第一种：可以像最长递增子序列一样用数组
第二种：仅需两个变量a，b
a代表长度为1最小元素，b代表长度为2最小元素。
a初始为第一个元素，b初始为INT_MAX
来了一个数，先和b比较，一旦这个数大于b，说明可以放在长度3，直接返回true，如果不大于b说明是小于等于b，然后和a做比较，如果大于a说明可以放在b的位置，如果小于a说明可以放在a的位置。
cpp
class Solution {
public:
bool increasingTriplet(vector<int>& nums) {
int n = nums.size();
int a = nums[0], b = INT_MAX;
for(int i = 1; i < n; ++i)
{
if(nums[i] > b) return true;
else if(nums[i] > a) b = nums[i];
else a = nums[i];
}
return false;
// int n = nums.size();
// vector<int> ret;
// ret.push_back(nums[0]);
// for(int i = 1; i < n; ++i)
// {
// if(nums[i] > ret.back())
// ret.push_back(nums[i]);
// else
// {
// int left = 0, right = ret.size() - 1;
// while(left < right)
// {
// int mid = (left + right) >> 1;
// if(ret[mid] < nums[i])
// left = mid + 1;
// else
// right = mid;
// }
// ret[left] = nums[i];
// }
// }
// return ret.size() >= 3 ? true : false;
}
};3.最长连续递增序列
题目链接： 674. 最长连续递增序列
题目分析：
给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。如果是连续的子序列其实就是子数组了，那这道题其实就变得简单了。
算法原理：
我们可以用暴力的思路来解决。用指针i固定一个数，然后再来一个指针j，让这个指针j向后移动，去找以i位置为起点的最长连续的递增序列。
怎么找？很简单，只要j位置元素比j-1位置元素大，j就往后移动，当j位置元素比j-1位置元素小就结束，此时就找完了以i位置为起点的最长连续的递增序列。
注意此时指针i并不直接向后移动1位，这里有一个小贪心，我们会发现 固定 i 位置然后找到这一段已经是递增并且是最长的，此时如果让i向后移动1位，那找的还是之前 i 位置的递增连续子序列，并且比之前的短，因此 i 移动到 j 位置，以 j 位起点在往后找。
所以我们这里的策略：贪心 + 双指针
cpp
class Solution {
public:
int findLengthOfLCIS(vector<int>& nums) {
int n = nums.size();
int i = 0, j = 0, ret = 0;
while(i < n)
{
j = i + 1;
// 找到递增区间的末端
while(j < n && nums[j] > nums[j - 1]) ++j;
ret = max(ret, j - i);
i = j;// 直接在循环中更新下⼀个位置的起点
}
return ret;
}
};