万人千题计划-37

推荐社区：万人千题

今日题解

最小时间差

思路：
如果时间差大于最大的时间差（12小时），说明从另一个方向时间差更小。比如：01：00 与16：00，时间差并不是16小时，而是24 - (16 - 1) = 9小时
不要忽略最早与最晚的时间的时间差，比如：00：00 与23：59分其实是连续的

class Solution {
public:
    int findMinDifference(vector<string>& timePoints) {
        int n = timePoints.size();
        int times[n];
        for (int i = 0; i < n; ++i) {
            times[i] = stoi(timePoints[i].substr(0,2))*60 + stoi(timePoints[i].substr(3,2));
        }

        sort(times, times+n);
        int res = INT_MAX;
        for (int i = 0; i < n-1; ++i) {
            res = min(res, times[i+1]-times[i]);
        }
        // 最后一个还要和第一个比较
        res = min(res, 24*60+times[0] - times[n-1]);

        return res;
    }
};

有序数组的平方

思路：双指针

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size()-1;
        vector<int> res(nums.size(), 0);
        for(int i=0, j=n; i<=j;) {// 注意这里要i <= j，因为最后要处理两个元素
            if(nums[i]*nums[i] < nums[j]*nums[j]) {
                res[n--] = nums[j] * nums[j];
                j--;
            }else {
                res[n--] = nums[i] * nums[i];
                i++;
            }
        }
        return res;
    }
};

优势洗牌

思路：相当于我们的田忌赛马，用最小的消耗去打败对方
对A和B进行快排，
每次在A中寻找大于B[i]的最小值，若没有，则返回A中的最小值

public:
    vector<int> advantageCount(vector<int>& A, vector<int>& B)//方法2
    {
        vector<pair<int,int>>v;
        vector<int>ans(A.size(),-1);

        for(int i=0;i<B.size();i++)
            v.push_back(make_pair(B[i],i));//pair排序默认按第一关键字升序,若第一关键字相同再按第二关键字

        sort(A.begin(),A.end());
        sort(v.begin(),v.end());

        int Al = 0,Ar = A.size()-1,Br = v.size()-1;
        while(Br >= 0)
        {
            if(A[Ar] > v[Br].first)//Amax>Bmax  Amax去对位Bmax
            {
                ans[v[Br].second] = A[Ar];
                Ar--;
            }
            else//Amax<Bmax   Amin去对位Bmax
            {
                ans[v[Br].second] = A[Al];
                Al++;
            }
            Br--;
        }
        return ans;
    }
};

救生艇

思路：用双指针蛮简单的
排序，然后看最重的能否跟最轻的一起走，如果可以，一起走，如果不行，单独走

class Solution {
public:
    int numRescueBoats(vector<int>& people, int limit) {
        sort(people.begin(), people.end());
        int l = 0, r = people.size() - 1;
        while(l < r) {
            if(people[r] + people[l] <= limit) {
                ++l;
            }
            --r;
        }
        return people.size() - l;
    }
};

判断子序列

思路：好像之前写过，用的双指针，定义两个指针 i 、j 分别指向 s 和 t 的初始位置。每次贪心地匹配，匹配成功则 i 和 j 同时右移，匹配 s 的下一个位置，匹配失败则 j 右移，i 不变，尝试用 t 的下一个字符匹配 s。

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int i=0, j=0;
        while( i< s.size() && j <t.size()) {
            if(s[i] == t[j]) {
                ++i;
            }
            ++j;
        }
        return i == s.size();
    }
};

搜索二维矩阵Ⅱ

思路：好像也写过。。。。
定义两个指针，一个从左到右，一个从上到下，无限逼近，若取到target，则返回true，否则返回false

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        if(matrix.size() == 0) return false;
        int i=0;
        int j = matrix[0].size()-1;
        while(i<matrix.size() && j >= 0) {
            if(matrix[i][j] == target) {
                return true;
            }
            if(matrix[i][j] < target) {
                ++i;
            }else --j;
        }
        return false;
    }
};

今天脑壳痛，写的脑袋晕乎乎的，难的也做不粗来，难受。
大伙，明天见哈，我感觉我需要吃点好吃的来缓和一下暴躁的心情