九日集训（每日打卡）第五天

1.912. 排序数组

排序模板题，可以练模板

class Solution {
public:
    void quick_sort(vector<int>& q,int l ,int r){
        if(l >= r) return;
        int i = l - 1,j = r + 1,x = q[(l + r) >> 1];
        while(i < j){
            do i++; while(q[i] < x);
            do j--; while(q[j] > x);
            if(i < j) swap(q[i],q[j]);
        }
        quick_sort(q,l,j);
        quick_sort(q,j + 1,r);
    }

    vector<int> sortArray(vector<int>& nums) {
        
        quick_sort(nums,0,nums.size() - 1);
        return nums;
    }
};

---

 2.169. 多数元素

 同时维护两个变量    r：当前存的数    c：当前数的数量

遍历，如果遍历的数与r里的数不一样，c--，一样，c++

因为题目视说有一个数的数量比其他所有数加起来的数量还多，所以一定是对的

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int r,c = 0;
        for(auto x : nums){
            if(!c) r = x,c = 1;
            else if(r == x) c++;
            else c--;
        }
        return r;
    }
};

---

3.217. 存在重复元素

1.可排序：遍历，看相邻元素是否相同，时间复杂度 是，空间复杂度

2.哈希表：遍历，看当前元素是否存到了表里，存在了就是true，没有就插入进去，如果遍历完都没有就false。时间复杂度和空间复杂度都是

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int> s;
        for(auto x : nums)
            if(s.count(x)) return true;
            else s.insert(x);
        return false;

    }
};

---

4.164. 最大间距

照着题做 

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

---

 5.905. 按奇偶排序数组

原地算法，参考快排，维护两个变量 ，。如果  的是偶数就往后走， 的是奇数就往前走，如果  的是奇数， 的是偶数，并且  就交换

class Solution {
public:
    vector<int> sortArrayByParity(vector<int>& nums) {
        int i = 0,j = nums.size() - 1;
        while(i < j){
            while(i < j && nums[i] % 2 == 0) i++;
            while(i < j && nums[j] % 2 == 1) j--;
            if(i < j) swap(nums[i],nums[j]);
        }
        return nums;
    }
};

---

6.539. 最小时间差

 这道题为了简便先都化成分钟，然后排序，比较相邻两个差值的大小。

注意：这是一个环形的，所以别忘记比较最后一个到第一个

class Solution {
public:
    int findMinDifference(vector<string>& timePoints) {
        int res = INT_MAX;
        vector<int> q;
        for(auto t : timePoints){
            int h,m;
            sscanf(t.c_str(), "%d:%d", &h, &m);
            q.push_back(h * 60 + m);
        }

        sort(q.begin(),q.end());

        for(int i = 1;i < q.size();i++) res = min(res,q[i] - q[i - 1]);
        res = min(res,24 * 60 - q.back() + q[0]);

        return res;
    }
};

---

 7.976. 三角形的最大周长

 为什么排序遍历相邻元素可行，有没有可能最优解为非相邻元素？（不会）

证明：反证 假设 a , b, c 为最优解，且存在a',b',满足 a < a' < b < b' < c（存在非相邻元素）

1. 由于 a + b > c，a < a', 有 a' + b > c，(a', b, c)优于(a, b, c),与(a, b, c)为最优解矛盾，故不存在a'
2. b'同理不存在 由于 a + b > c, b < b'，有a + b' > c，(a, b, c)为最优解矛盾，故不存在b'

因此最优解一定为排序后相邻元素

class Solution {
public:
    int largestPerimeter(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        int n = nums.size() - 1;
        
        for(int i = n;i>=2;i--)
            if(nums[i] < nums[i - 1] + nums[i - 2])
                return  (nums[i] + nums[i - 1] + nums[i - 2]);

        return 0;
    }
};

---

 8.881. 救生艇

 双指针遍历，一个从前面走，一个从后面走，如果当前最大的体重加最小的体重小于limit，几个人就一起走，否则就只让最大的走。

class Solution {
public:
    int numRescueBoats(vector<int>& people, int limit) {
        sort(people.begin(),people.end());

        int i = 0,j = people.size() - 1,ans = 0;
        while(i <= j){
            if(people[j] + people[i] <= limit)
                i++;
            j--;
            ans++;
        }
        return ans;
    }
};

---