给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组是数组中的一个连续部分。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

class Solution {
public://贪心算法int maxSubArray(vector<int>& nums) {int res=INT_MIN;int sum=0;for(int i=0; i<nums.size(); i++){sum+=nums[i];if(sum>res) {res=sum;}if(sum<0) {sum=0;}//最关键的}return res;}
};

**解释：**到负数就选择起始位置，还是连续和为负选择起始位置？

动画演示用，可以发现， 4遇到 -1的时候，我们依然累加了，为什么呢？

因为和为 3，只要连续和还是正数就会 对后面的元素 起到增大总和的作用。 所以只要连续和为正数我们就保留。

这里也会有录友疑惑，那 4 +（-1） 之后 不就变小了吗？ 会不会错过 4 成为最大连续和的可能性？

其实并不会，因为还有一个变量 result 一直在更新 最大的连续和，只要有更大的连续和出现，result 就更新了，那么 result 已经把 4 更新了，后面 连续和变成 3，也不会对最后结果有影响。

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。

返回 你能获得的 最大 利润 。

示例 1：

输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。
最大总利润为 4 + 3 = 7 。

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
最大总利润为 4 。

示例 3：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0。

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

给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。

每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:

• 0 <= j <= nums[i]
• i + j < n

返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

示例 1:

输入: nums = [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

示例 2:

输入: nums = [2,3,0,1,4]
输出: 2

class Solution {
public:int jump(vector<int>& nums) {if(nums.size()<=1) return 0;int curDistance=0;int nextDistance=0;int ans=0;for(int i=0; i<nums.size(); i++){nextDistance = max(nums[i]+i,nextDistance);if(i==curDistance){ans++;curDistance=nextDistance;if(nextDistance>=nums.size()-1) break;}}return ans;}
};

在一条环路上有 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) {vector<int> cha(gas.size(),0);int sum=0;int res=0;for(int i=0; i<cost.size(); i++){cha[i]=(gas[i]-cost[i]);sum+=gas[i]-cost[i];}int sum2=0;if(sum<0){return -1;}else{for(int i=0; i<cha.size(); i++){sum2+=cha[i];if(sum2<0){//只要出现<0,肯定有不符合，下一个开始重扫res=i+1;//体现贪心的地方，类似最大子数组和那题sum2=0;}}}return res;}
};

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

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

• 每个孩子至少分配到 1 个糖果。
• 相邻两个孩子评分更高的孩子会获得更多的糖果。

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

示例 1：

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

示例 2：

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

//从前往后扫一遍，最小为1，右边比左边大+1
//再从后往前扫一遍，最小为1，左边比右边大+1
//然后每个位置取最大的，然后累加求和
class Solution {
public:int candy(vector<int>& ratings) {vector<int> index(ratings.size(),1);for(int i=0; i<ratings.size()-1; i++){if(ratings[i+1]>ratings[i]) {index[i+1]=index[i]+1;}}for(int i=ratings.size()-1; i>0; i--){if(ratings[i]<ratings[i-1]) {index[i-1]=max(index[i-1],index[i]+1);}}int sum=0;for(int i=0; i<index.size(); i++){sum+=index[i];}return sum;}
};

假设有打乱顺序的一群人站成一个队列，数组 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]] 是重新构造后的队列。

class Solution {
public:vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {for(int i=0; i<people.size(); i++){//顺带回顾一下冒泡排序for(int j=0; j<people.size()-1-i; j++){//'-1'是因为下面'j+1'会溢出； '-i'是最小的已在后面累计了，不需要比较排序了if(people[j][0]<people[j+1][0]){vector<int> temp=people[j];people[j]=people[j+1];people[j+1]=temp;}else if(people[j][0]==people[j+1][0]){if(people[j][1]>people[j+1][1]){vector<int> temp=people[j];people[j]=people[j+1];people[j+1]=temp;}}}}//解题核心，贪心算法，先按照身高h从大到小排，身高相等k越小越往前//然后第二轮根据每一行元素k值插入对应数组序列上就可以了vector<vector<int>> que;for(int i=0; i<people.size(); i++){int position = people[i][1];que.insert(que.begin()+position,people[i]);}return que;}
};

class Solution {
public://static静态的，限制作用范围，延长生命周期static bool cmp(vector<int> &a, vector<int> &b){if(a[0]==b[0]){return a[1]<b[1];}else{return a[0]>b[0];}}//用sort后,排序速度明显提高vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {sort(people.begin(),people.end(),cmp);//解题核心，贪心算法，先按照身高h从大到小排，身高相等k越小越往前//然后第二轮根据每一行元素k值插入对应数组序列上就可以了vector<vector<int>> que;for(int i=0; i<people.size(); i++){int position = people[i][1];que.insert(que.begin()+position,people[i]);}return que;}
};

//这样链表插值更快一点
class Solution {
public://static静态的，限制作用范围，延长生命周期1static bool cmp(vector<int> &a, vector<int> &b){if(a[0]==b[0]){return a[1]<b[1];}else{return a[0]>b[0];}}vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {sort(people.begin(),people.end(),cmp);//解题核心，贪心算法，先按照身高h从大到小排，身高相等k越小越往前//然后第二轮根据每一行元素k值插入对应数组序列上就可以了list<vector<int>> que;//链表插值更快for(int i=0; i<people.size(); i++){int position = people[i][1];list<vector<int>>::iterator it=que.begin();while (position--){it++;}que.insert(it,people[i]);}return vector<vector<int>>(que.begin(), que.end());;}
};

有一些球形气球贴在一堵用 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支箭。

//本质就是求不重叠区间的数量，和后面那题原理一致
class Solution {
public:static bool cmp(vector<int> a, vector<int> b){return a[1]<b[1];}int findMinArrowShots(vector<vector<int>>& points) {if(points.size()==0) return 0;sort(points.begin(),points.end(),cmp);int res=1;int end=points[0][1];for(int i=0; i<points.size(); i++){if(points[i][0]>end){res++;end=points[i][1];}}return res;}
};

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

注意 只在一点上接触的区间是 不重叠的。例如 [1, 2] 和 [2, 3] 是不重叠的。

示例 1:

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

示例 2:

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

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 res=1;int end = intervals[0][1];for(int i=1; i<intervals.size(); i++){if(intervals[i][0]>=end){//注意这题可以'='res++;end=intervals[i][1];}}return intervals.size()-res;}
};

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

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

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

示例 1：

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

class Solution {
public:vector<int> partitionLabels(string s) {unordered_map<char, int> map;for(int i=0; i<s.length(); i++){map[s[i]]=i;}vector<int> result;int left=0;int right=0;for(int i=0; i<s.length(); i++){right = max(right, map[s[i]]);//更新这个字符最后出现的位置//这样保证在right重置前，之前的right一直更新到i=right时截至if(i==right){result.push_back(right-left+1);left=i+1;}}return result;}
};

以数组 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 {
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>> res;if(intervals.size()==0) return res;sort(intervals.begin(), intervals.end(), cmp);vector<int> end = intervals[0];for(int i=1; i<intervals.size(); i++){if(intervals[i][0]>end[1]){//不重叠res.push_back(end);//将前面的end放入结果中end=intervals[i];//更新现在的end}else{end[1] = max(end[1], intervals[i][1]);//如果重叠，进行合并更新右边界}}res.push_back(end);return res;}
};