学会贪心2

7. K次取反后最大化的数组和

给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：

• 选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。

重复这个过程恰好 k 次。可以多次选择同一个下标 i 。

以这种方式修改数组后，返回数组 可能的最大和 。

示例 1：

输入：nums = [4,2,3], k = 1
输出：5
解释：选择下标 1 ，nums 变为 [4,-2,3] 。

示例 2：

输入：nums = [3,-1,0,2], k = 3
输出：6
解释：选择下标 (1, 2, 2) ，nums 变为 [3,1,0,2] 。

示例 3：

输入：nums = [2,-3,-1,5,-4], k = 2
输出：13
解释：选择下标 (1, 4) ，nums 变为 [2,3,-1,5,4] 。

分析

首先将所有的数按照绝对值从大到小排序，然后依次将负数变成正数

然后看还有多少次变换，奇数次就将最小的数变成负数，偶数次直接返回

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

贪心的思路，局部最优：让绝对值大的负数变为正数，当前数值达到最大，整体最优：整个数组和达到最大。

局部最优可以推出全局最优。

8.加油站

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

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

给定两个整数数组 gas 和 cost ，如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -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; i < n; i++) {//从每个加油站出发
			int total_gas = gas[i];
			int j = i;//从i出发
			int length = 0;//记录走的长度
			while (total_gas > 0) {
				total_gas -= cost[j];//油量减去到下一个站点的花费
				if (total_gas < 0) break;//不能到下一个加油站
				//到下一个加油站
				if (j == n - 1)j = 0;
				else j++;
				length++;
				if (length == n ) return i;//转了一圈
				total_gas += gas[j];//加上油
			}
		}
		return -1;
	}
};

35 / 39 通过，超时

贪心

每个加油站的剩余量rest[i]为gas[i] - cost[i]。

i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。

局部最优：当前累加rest[i]的和curSum一旦小于0，起始位置至少要是i+1，因为从i之前开始一定不行。全局最优：找到可以跑一圈的起始位置。

如果要从a跑到b，则这中间的res加起来一定是大于0的，一旦小于0就从下一个站点出发

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

9.分发糖果

n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。

你需要按照以下要求，给这些孩子分发糖果：

• 每个孩子至少分配到 1 个糖果。

• 相邻两个孩子评分更高的孩子会获得更多的糖果。

请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。

示例 1：

输入：ratings = [1,0,2]
输出：5
解释：你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。

示例 2：

输入：ratings = [1,2,2]
输出：4
解释：你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。
     第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。

思路一

贪心策略：

局部最优：每个“V”求最优

全局最优：所有"V"最优构成整体最优**

在一排小朋友中，存在以下两种情况

1.所有孩子分数都相等，则只需要给每个孩子分一个糖果就好，即可直接返回

2.不是所有孩子的分数都相等

针对第二种情况，一定存在一个或多个极小值点，采用一个数组min_friend记录这些极小值点。

对每个极小值点两侧的元素采取如下策略：

以该极小值点位中心，依次向两侧求解，

a. 如果外侧的小朋友分数比相邻内侧的小朋友分数高，则外侧小朋友得糖果数=内侧小朋友糖果数+1；

b. 如果外侧的小朋友分数等于相邻内侧的小朋友分数，则外侧小朋友得糖果数=1（题目只说相邻两小朋友分数高的糖果多，没说分数相等糖果数就得相等）

c. 如果外侧的小朋友分数小于相邻内侧的小朋友分数，说明进入另一个极小值点的“范围”了，直接退出

值得注意的是“V”形的左右两个顶点，如果该点已经作为其他的极小值点的顶点了的话，需要给该顶点取满足两个"V"的最小值

代码如下，除V形的交界点外，每个点都只求过一次，时间复杂度为O(n)

class Solution {
public:
	int candy(vector<int>& ratings)
	{
		if (ratings.size() <= 1)return ratings.size();//保证下面程序至少有两个小朋友
		vector<int> candy_num(ratings.size(),INT_MAX);
		vector<int> min_friend;//
		//给V字形最低的小朋友给一块糖
		if (ratings[0] < ratings[1]) {
			candy_num[0] = 1;
			min_friend.push_back(0);
		}
		if (ratings[ratings.size() - 1] < ratings[ratings.size() - 2]) {
			candy_num[ratings.size() - 1] = 1;
			min_friend.push_back(ratings.size() -1);
		}
		for (int i = 1; i <= ratings.size()-2; i++) {
			if ((ratings[i] <= ratings[i - 1] && ratings[i] < ratings[i + 1])|| (ratings[i] < ratings[i - 1] && ratings[i] <= ratings[i + 1])) {
				candy_num[i] = 1;
				min_friend.push_back(i);
			}
		}
		if (min_friend.size() == 0)return ratings.size();//没有最低点
		//从每个“谷点”小朋友开始分别往左，往右遍历
		while (!min_friend.empty()) {
			int pos = min_friend[0];
			min_friend.erase(min_friend.begin());
			int left = pos - 1, right = pos + 1;
			while (left >= 0) {//先往左走
				if (ratings[left] < ratings[left + 1]) break;
				if (candy_num[left] == INT_MAX) {//还没有被赋值
					if (ratings[left] > ratings[left + 1]) candy_num[left] = candy_num[left + 1] + 1;
					if (ratings[left] == ratings[left + 1]) candy_num[left] = 1;// candy_num[left + 1];
				}
				else {
					if (ratings[left] > ratings[left + 1]) candy_num[left] = max(candy_num[left],candy_num[left + 1] + 1);
					if (ratings[left] == ratings[left + 1]) candy_num[left] = max(candy_num[left], 1);
				}
				left--;
			}
			while (right<=ratings.size()-1) {//再往右走
				if (ratings[right] < ratings[right - 1]) break;
				if (candy_num[right] == INT_MAX) {//还没有被赋值
					if (ratings[right] > ratings[right - 1]) candy_num[right] = candy_num[right - 1] + 1;
					if (ratings[right] == ratings[right - 1]) candy_num[right] = 1;
				}
				else {
					if (ratings[right] > ratings[right - 1]) candy_num[right] = max(candy_num[right], candy_num[right - 1] + 1);
					if (ratings[right] == ratings[right- 1]) candy_num[right] = max(candy_num[right], 1);
				}
				right++;
			}
		}
		long long sum=0;
		for (int ele : candy_num) sum += ele;
		return sum;
	}
};

思路二

局部最优：

（1）从左往右遍历，对每个小朋友，如果右边相邻小朋友的分数更高，保证其得到更多的糖果

（2）从右往左遍历，对每个小朋友，如果左边相邻小朋友的分数更高，保证其得到更多的糖果

全局最优：保证每个元素同时满足上面的两个局部最优

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

10 柠檬水找零

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。

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

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

给你一个整数数组 bills ，其中 bills[i] 是第 i 位顾客付的账。如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

示例 1：

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

示例 2：

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

分析

贪心：尽量先把10块的找零找出去，多留5块的

class Solution {
public:
	bool lemonadeChange(vector<int>& bills) {
		vector<int> money(3, 0);//分别表示5，10，20的数目
		//20的优先找零10块的
		int profit = 0;
		for (int i = 0; i < bills.size(); i++) {
			if (bills[i] == 5)money[0]++;
			if (bills[i] == 10) {
				money[0]--;
				money[1] += 1;
			}
			if (bills[i] == 20) {
				if (money[1] > 0) {
					money[1]--;
					money[0]--;
				}
				else money[0] -= 3;
				money[2]++;
			}
			if (money[0] < 0 || money[1] < 0 || money[2] < 0)return false;
		}
		return true;
	}
};

11.根据身高重建队列

假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。

请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。

示例 1：

输入：people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
输出：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]
解释：
编号为 0 的人身高为 5 ，没有身高更高或者相同的人排在他前面。
编号为 1 的人身高为 7 ，没有身高更高或者相同的人排在他前面。
编号为 2 的人身高为 5 ，有 2 个身高更高或者相同的人排在他前面，即编号为 0 和 1 的人。
编号为 3 的人身高为 6 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
编号为 4 的人身高为 4 ，有 4 个身高更高或者相同的人排在他前面，即编号为 0、1、2、3 的人。
编号为 5 的人身高为 7 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
因此 [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] 是重新构造后的队列。

示例 2：

输入：people = [[6,0],[5,0],[4,0],[3,2],[2,2],[1,4]]
输出：[[4,0],[5,0],[2,2],[3,2],[1,4],[6,0]]

分析：由大到小依次插入，当前面的元素插入后，后面元素的位置就确定了

局部最优：优先按身高高的people的k来插入。插入操作过后的people满足队列属性

全局最优：最后都做完插入操作，整个队列满足题目队列属性

class Solution {
public:
	static bool cmp(vector<int> a, 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>> que;
		for (int i = 0; i < people.size(); i++) {
			int pos = people[i][1];
			que.insert(que.begin() + pos, people[i]);
		}
		return que;
	}
};

采用链表改进

class Solution {
public:
	static bool cmp(vector<int> a, 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);
		list<vector<int>> que;
		for (int i = 0; i < people.size(); i++) {
			int pos = people[i][1];
			list<vector<int>>::iterator it= que.begin();
			while (pos--)it++;
			que.insert(it, people[i]);
		}
		return vector<vector<int>>(que.begin(),que.end());
	}
};

12用最少数量的箭引爆气球

有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。

一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 x``start，x``end， 且满足 xstart ≤ x ≤ x``end，则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后，可以无限地前进。

给你一个数组 points ，返回引爆所有气球所必须射出的 最小 弓箭数 。

示例 1：

输入：points = [[10,16],[2,8],[1,6],[7,12]]
输出：2
解释：气球可以用2支箭来爆破:
-在x = 6处射出箭，击破气球[2,8]和[1,6]。
-在x = 11处发射箭，击破气球[10,16]和[7,12]。

示例 2：

输入：points = [[1,2],[3,4],[5,6],[7,8]]
输出：4
解释：每个气球需要射出一支箭，总共需要4支箭。

示例 3：

输入：points = [[1,2],[2,3],[3,4],[4,5]]
输出：2
解释：气球可以用2支箭来爆破:
- 在x = 2处发射箭，击破气球[1,2]和[2,3]。
- 在x = 4处射出箭，击破气球[3,4]和[4,5]。

分析

局部最优：每个气球都要被击落，即需要一只箭，我们的局部最优就是让这只箭穿过更多的气球

全局最优：用更少的箭射下全部气球

思路

遍历每个x，然后从达到下依次排列穿过气球更多的x

class Solution {
	static bool cmp(vector<int>a, vector<int>b) {
		return a[0] < b[0];
	}
public:
	int findMinArrowShots(vector<vector<int>>& points) {
		sort(points.begin(), points.end(), cmp);
		int result = 0;
		for (int i = 0; i < points.size(); i++) {
			result++;
			int flag = 0;
			int j = i + 1;
			int min_1 = points[i][1];
			for (; j < points.size(); j++) {//保证穿过i的箭更多的穿过后面的气球
				if (points[j][0]>min_1) {//保证后面的气球能够一起穿过
					break;
				}
				min_1 = min(min_1, points[j][1]);
				flag++;
			}
			if(flag!=0)i = i+flag;
		}
		return result;
	}
};

超时了，通过47/50

把cmp参数值传递改成引用，可以通过

class Solution {
	static bool cmp(vector<int>&a, vector<int>&b) {
		return a[0] < b[0];
	}
public:
	int findMinArrowShots(vector<vector<int>>& points) {
		sort(points.begin(), points.end(), cmp);
		int result = 0;
		for (int i = 0; i < points.size(); i++) {
			result++;
			int flag = 0;
			int j = i + 1;
			int min_1 = points[i][1];
			for (; j < points.size(); j++) {//保证穿过i的箭更多的穿过后面的气球
				if (points[j][0]>min_1) {//保证后面的气球能够一起穿过
					break;
				}
				min_1 = min(min_1, points[j][1]);
				flag++;
			}
			if(flag!=0)i = i+flag;
		}
		return result;
	}
};

代码随想录.

前后两种方法时间复杂度都是O(n)

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

13.无重叠区间

给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。

示例 1:

输入: intervals = [[1,2],[2,3],[3,4],[1,3]]
输出: 1
解释: 移除 [1,3] 后，剩下的区间没有重叠。

示例 2:

输入: intervals = [ [1,2], [1,2], [1,2] ]
输出: 2
解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。

示例 3:

输入: intervals = [ [1,2], [2,3] ]
输出: 0
解释: 你不需要移除任何区间，因为它们已经是无重叠的了。

分析：贪心

按照起点由小到大对元素进行排序.

每个元素与前一个元素有两种情况:

1. 前一个元素包含后一个元素，那么应该删除前一个元素

2. 前一个元素与后一个元素交叉，那么应该删除后一个元素

代码如下：

class Solution {
    static bool cmp(vector<int>& a, vector<int>& b) {
        if (a[0] == b[0])return a[1] < b[1];
        return a[0] < b[0];
    }
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if (intervals.size() <= 1)return 0;
        //将元素按照起点由小到大，起点相同时终点小的排前面的顺序排序，然后判断每个元素的起点是否与前一个元素的终点交叉
        sort(intervals.begin(), intervals.end(), cmp);
        int result = 0;
        for (int i = 1; i < intervals.size(); i++) {
            if (intervals[i][0] < intervals[i - 1][1]) {
                if(intervals[i][1]<=intervals[i-1][1]) intervals.erase(intervals.begin() + i-1);
                else intervals.erase(intervals.begin() + i);
                i--;
                result++;
            }
        }
        return result;
    }
};

上面的代码超时了，应该是erase操作太费时间了，其实删除操作可以从逻辑上进行，不一定要真的删除，改进后代码如下

class Solution {
    static bool cmp(vector<int>& a, vector<int>& b) {
        if (a[0] == b[0])return a[1] < b[1];
        return a[0] < b[0];
    }
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if (intervals.size() <= 1)return 0;
        //将元素按照起点由小到大，起点相同时终点小的排前面的顺序排序，然后判断每个元素的起点是否与前一个元素的终点交叉，若交叉则删除此元素
        sort(intervals.begin(), intervals.end(), cmp);
        int result = 0;
        int end = 0;//记录i前未删除元素的末尾元素
        for (int i = 1; i < intervals.size(); i++) {
            if (intervals[i][0] < intervals[end][1]) {//如果有重叠
                if (intervals[i][1] > intervals[end][1]) {//如果是交叉关系
                    end = end;
                    result++;
                }
                if (intervals[i][1] <= intervals[end][1]) {//如果是包含关系
                    end = i;
                    result++;
                }
            }
            else end = i;//如果无重叠
        }
        return result;
    }
};

14划分字母区间

给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。

注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s 。

返回一个表示每个字符串片段的长度的列表。

示例 1：

输入：s = "ababcbacadefegdehijhklij"
输出：[9,7,8]
解释：
划分结果为 "ababcbaca"、"defegde"、"hijhklij" 。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 这样的划分是错误的，因为划分的片段数较少。 

示例 2：

输入：s = "eccbbbbdec"
输出：[10]

分析：记录每个字母的最大最小区间，然后对区间进行合并

两个前后区间的关系：相交（如1，3和2，4），包含（如1，4和2，3），没关系（如1，2和3，4）

针对前两种需要对区间进行合并，第三种不需要处理

class Solution {
public:
	static bool cmp(vector<int>a, vector<int>b) {
		return a[0] < b[0];
	}
	vector<int> partitionLabels(string s) {
		if (s.size() == 0)return 0;
		vector < vector<int>> start_end(26, vector<int>(2,-1));
		for (int i = 0; i < s.size(); i++) {
			if (start_end[s[i] - 'a'][0] == -1)start_end[s[i] - 'a'][0] = i;//start只第一次时更新
			start_end[s[i] - 'a'][1] = i;//end每次都更新，因此指向末尾
		}
		//删除没有字母的区间
		vector < vector<int>> s_e_;
		for (vector<int>ele : start_end) {
			if (ele[0] != -1)s_e_.push_back(ele);
		}
		//对s_e_按照起点由小到大排序
		sort(s_e_.begin(), s_e_.end(), cmp);
		//进行合并
		for (int i = 1; i < s_e_.size(); i++) {
			//前后交叉
			if (s_e_[i][1] > s_e_[i - 1][1]&&s_e_[i][0]<s_e_[i-1][1]) {
				s_e_[i - 1][1] = s_e_[i][1];
				s_e_.erase(s_e_.begin() + i);
				i--;
				continue;
			}
			//前后包含
			if (s_e_[i][1] < s_e_[i - 1][1]) {
				s_e_.erase(s_e_.begin() + i);
				i--;
				continue;
			}
			//不相交
		}
		vector<int> result;
		for (vector<int>ele : s_e_)result.push_back(ele[1] - ele[0] + 1);
		return result;
	}
};

改进：融合交叉和前后包含两种情况，并采用逻辑上的删除代替实际的删除

class Solution {
public:
	static bool cmp(vector<int>a, vector<int>b) {
		return a[0] < b[0];
	}
	vector<int> partitionLabels(string s) {
		if (s.size() == 0)return { 0 };
		vector < vector<int>> start_end(26, vector<int>(2, -1));
		for (int i = 0; i < s.size(); i++) {
			if (start_end[s[i] - 'a'][0] == -1)start_end[s[i] - 'a'][0] = i;//start只第一次时更新
			start_end[s[i] - 'a'][1] = i;//end每次都更新，因此指向末尾
		}
		//删除没有字母的区间
		vector < vector<int>> s_e_;
		for (vector<int>ele : start_end) {
			if (ele[0] != -1)s_e_.push_back(ele);
		}
		//对s_e_按照起点由小到大排序
		sort(s_e_.begin(), s_e_.end(), cmp);
		//进行合并
		vector < vector<int>> result;
		result.push_back(s_e_[0]);
		for (int i = 1; i < s_e_.size(); i++) {
			//如果有交叉
			if (s_e_[i][0] <= result.back()[1]) {
				result.back()[1] = max(s_e_[i][1], result.back()[1]);
			}
			else result.push_back(s_e_[i]);
		}
		vector<int> result_;
		for (vector<int>ele : result)result_.push_back(ele[1] - ele[0] + 1);
		return result_;
	}
};

15.合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2：

输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

class Solution {
	static bool cmp(vector<int>&a, vector<int>&b) {
		return a[0] < b[0];
	}
public:
	vector<vector<int>> merge(vector<vector<int>>& intervals) {
		if (intervals.size() <= 1) return intervals;
		sort(intervals.begin(), intervals.end(), Solution::cmp);
		for (int i = 1; i < intervals.size(); i++) {
			//判断当前元素和后一个元素的关系
			//交叉
			if (intervals[i][0] <= intervals[i - 1][1] && intervals[i][1] > intervals[i - 1][1]) {
				intervals[i - 1][1] = intervals[i][1];
				intervals.erase(intervals.begin() + i);
				i--;
				continue;
			}
			//被前一个元素包含
			if (intervals[i][1] <= intervals[i - 1][1]) {
				intervals.erase(intervals.begin() + i);
				i--;
				continue;
			}
			//不相交
		}
		return intervals;
	}
};

超时了，erase操作费时，进行逻辑上的删除

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

16.单调递增的数字

当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。

给定一个整数 n ，返回 小于或等于 n 的最大数字，且数字呈 单调递增 。

示例 1:

输入: n = 10
输出: 9

示例 2:

输入: n = 1234
输出: 1234

示例 3:

输入: n = 332
输出: 299

分析：依次给n减去1直到满足要求

class Solution {
public:
	bool func(int n) {
		//如果是递增数，返回true，反之返回false
		vector<int>record;
		while (n) {
			record.emplace_back(n % 10);
			n /= 10;
		}
		for (int i = 1; i < record.size(); i++) {
			if (record[i] > record[i - 1])return false;
		}
		return true;
	}
	int monotoneIncreasingDigits(int n) {
		while (!func(n)) {
			n--;
		}
		return n;
	}
};

超时了，通过203/308

改进，在func函数边push的时候边判断

class Solution {
public:
	bool func(int n) {
		//如果是递增数，返回true，反之返回false
		if (n <= 9)return true;
		if (n == 10)return false;
		int pre = n % 10;
		n /= 10;
		int cur;
		while (n) {
			cur = n % 10;
			if (cur > pre)return false;
			pre = cur;
			n /= 10;
		}
		return true;
	}
	int monotoneIncreasingDigits(int n) {
		while (!func(n)) {
			n--;
		}
		return n;
	}
};

超时，通过234 / 308

贪心

例如：98，一旦出现strNum[i - 1] > strNum[i]的情况（非单调递增），首先想让strNum[i - 1]--，然后strNum[i]给为9，这样这个整数就是89，即小于98的最大的单调递增整数

class Solution {
public:
	int monotoneIncreasingDigits(int n) {
		string s = to_string(n);
		int flag = INT_MAX-1;
		for (int i = s.size() - 1; i >= 1; i--) {
			if (s[i] < s[i - 1]) {
				s[i - 1] -= 1;
				flag = i - 1;
				s[i] = 9;
			}
		}
		for (int i = flag + 1; i <= s.size() - 1; i++)s[i] = '9';
		return stoi(s);//stoi（字符串，起始位置，n进制（默认10进制）），将 n 进制的字符串转化为十进制
	}
};

17 监控二叉树

给定一个二叉树，我们在树的节点上安装摄像头。

节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。

计算监控树的所有节点所需的最小摄像头数量。

示例 1：

输入：[0,0,null,0,0]
输出：1
解释：如图所示，一台摄像头足以监控所有节点。

示例 2：

输入：[0,0,null,0,null,0,null,null,0]
输出：2
解释：需要至少两个摄像头来监视树的所有节点。 上图显示了摄像头放置的有效位置之一。

分析：动态规划

若在root 处安放摄像头，则孩子 left, right 一定也会被监控到。此时，只需要保证 left的两棵子树被覆盖，同时保证 right 的两棵子树也被覆盖即可。否则， 如果 root 处不安放摄像头，则除了覆盖 root的两棵子树之外，孩子 left,right 之一必须要安装摄像头，从而保证root 会被监控到。

class Solution {
public:
	vector<int>minCamera(TreeNode* root) {
		if (root == nullptr)return { INT_MAX / 2, 0,0 };
		//0表示root安装摄像头，覆盖整棵树需要的摄像头数目，
		//1表示覆盖整棵树需要的摄像头数目，无论 root是否放置摄像头,
		//2表示覆盖两棵子树需要的摄像头数目，无论节点 root本身是否被监控到。
		vector<int> left = minCamera(root->left);
		vector<int> right = minCamera(root->right);

		int val_0 = left[2] + right[2] + 1;
		int val_1 = min(val_0, min(left[0] + right[1], right[0] + left[1]));
		int val_2 = min(val_0, left[1] + right[1]);

		return { val_0,val_1,val_2 };
	}
	int minCameraCover(TreeNode* root) {
		vector<int> result = minCamera(root);
		return result[1];
	}
};