2.28 log | 406.根据身高重建队列，452. 用最少数量的箭引爆气球，435. 无重叠区间,763.划分字母区间，56. 合并区间，738.单调递增的数字

406.根据身高重建队列

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

本题值得注意的一点是对people数组的从大到小排序以及身高相等时又降序，排完序之后要新建一个vector数组储存调序后的vector数组，因为如果在原基础上调序对可能会对同一组序列进行反复调序，小的往前调不会影响大的排序，大的是从大到小依次调不会产生大的往后调的情况，都是往前调

452. 用最少数量的箭引爆气球

class Solution {
public:
    static bool cmp(vector<int>& a,vector<int>& b){
        return a[0]<b[0];
    }
    int findMinArrowShots(vector<vector<int>>& points) {
        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],points[i-1][1]);
            }
        }
        return result;
    }
};

这道题就是看有多少区间是重合的，首先对元素拉通排序， 比较当前元素的左边界和前一个元素右边界的大小，如果不重合result++，重合则当前元素的右边界变为两个区间右边界的最小值，进入下一层判断。

435. 无重叠区间

class Solution {
public:
    static bool cmp(vector<int>& a,vector<int>& b){
        return a[0]<b[0];
    }
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        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]){
                continue;
            }else {
                result++;
                intervals[i][1]=min(intervals[i][1],intervals[i-1][1]);
            }
        }
        return result;
    } 
};

这道题和上题代码都没什么太大区别，判断重叠区间的个数

763.划分字母区间 

class Solution {
public:
    vector<int> partitionLabels(string s) {
        int hash[27]={0};
        for(int i=0;i<s.size();i++){
            hash[s[i]-'a']=i;
        }
        vector<int> result;
        int left=0;
        int right=0;
        for(int i=0;i<s.size();i++){
            right=max(right,hash[s[i]-'a']);
            if(i==right){
                result.push_back(right-left+1);
                left=i+1;
            }
        }
        return result; 
    }
};

这道题用到了hash表，将26的字母映射到hash表，hash表记录的是字母出现的最远下标，用left和right来划分字母区间，right不断更新为遍历到的字母的最远下标，当所走到的字母下标等于right时分隔字母串，result记录分割的字母串长度，left=i+1

56. 合并区间

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) {
        sort(intervals.begin(),intervals.end(),cmp);
        vector<vector<int>> result;
        if(intervals.size()==1) return intervals;
        for(int i=1;i<intervals.size();i++){
            if(intervals[i][0]<=intervals[i-1][1]){
                intervals[i][1]=max(intervals[i][1],intervals[i-1][1]);
                intervals[i][0]=intervals[i-1][0];
            }else {
                result.push_back(intervals[i-1]);
            }
            if(i==intervals.size()-1) result.push_back(intervals[i]);
        }
        return result; 
    }
};

这道题也和前面的题类似，不过是缩减区间变成扩充区间，重合就扩充区间，不重合就记录上一个区间，最后如果遍历到了最后一个元素，则直接记录最后一个元素

738.单调递增的数字

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

 本题就是要提前找到规律，从右到左遍历，不断更新s[i]<s[i-1]的i值，用flag记录更新i值，最后得出结果为s[i-1]--,s[i]之后的都为9，int型转换为string类型用to_string，string类型转换为int型用stoi