Leetcode 第 400 场周赛题解

Leetcode 第 400 场周赛题解

题目1：3168. 候诊室中的最少椅子数

思路

模拟。

代码

/*
 * @lc app=leetcode.cn id=3168 lang=cpp
 *
 * [3168] 候诊室中的最少椅子数
 */

// @lc code=start
class Solution
{
public:
    int minimumChairs(string s)
    {
        int chair = 0;
        int max_chair = INT_MIN;
        for (char &c : s)
        {
            if (c == 'E')
            {
                chair++;
                if (chair > max_chair)
                    max_chair = chair;
            }
            else
                chair--;
        }
        return max_chair;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(n)，其中 n 是字符串 s 的长度。

空间复杂度：O(1)。

题目2：3169. 无需开会的工作日

思路

按 LeetCode56.合并区间 的做法，把 meetings 数组中所有重叠的区间合并起来，再统计其中无需开会的工作日个数。

代码

/*
 * @lc app=leetcode.cn id=3169 lang=cpp
 *
 * [3169] 无需开会的工作日
 */

// @lc code=start
class Solution
{

public:
    int countDays(int days, vector<vector<int>> &meetings)
    {

        vector<vector<int>> m = merge(meetings);
        int n = m.size();
        int count = m[0][0] - 1;
        for (int i = 1; i < n; i++)
        {
            if (m[i][0] > m[i - 1][1])
                count += m[i][0] - m[i - 1][1] - 1;
        }
        count += max(0, days - m[n - 1][1]);
        return count;
    }
    // 辅函数- 合并区间
    vector<vector<int>> merge(vector<vector<int>> &intervals)
    {
        // 特判
        if (intervals.empty())
            return {};

        int n = intervals.size();
        sort(intervals.begin(), intervals.end(),
             [&](const vector<int> &v1, const vector<int> &v2)
             {
                 return v1[0] < v2[0];
             });
        vector<vector<int>> ans;
        for (int i = 0; i < n; i++)
        {
            int left = intervals[i][0], right = intervals[i][1];
            if (ans.empty() || ans.back()[1] < left)
                ans.push_back({left, right});
            else
                ans.back()[1] = max(ans.back()[1], right);
        }
        return ans;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(nlogn)，其中 n 是数组 meetings 的长度。

空间复杂度：O(n)，其中 n 是数组 meetings 的长度。

题目3：3170. 删除星号以后字典序最小的字符串

思路

由于要去掉最小的字母，为了让字典序尽量小，相比去掉前面的字母，去掉后面的字母更好。

从左到右遍历字符串 s，用 26 个栈模拟，其中第 i 个栈维护第 i 个小写字母的下标。

遇到 * 时，弹出第一个非空栈的栈顶下标。

最后把所有栈顶下标对应的字母组合起来，即为答案。

具体实现时，把要删除的字符修改成 *，最后把字符串的 * 全部去掉即为答案。

代码

/*
 * @lc app=leetcode.cn id=3170 lang=cpp
 *
 * [3170] 删除星号以后字典序最小的字符串
 */

// @lc code=start
class Solution
{
public:
    string clearStars(string s)
    {
        int n = s.length();
        stack<int> idx[26];
        for (int i = 0; i < n; i++)
        {
            if (s[i] != '*')
            {
                idx[s[i] - 'a'].push(i);
                continue;
            }
            // 遇到 *
            for (auto &stk : idx)
            {
                if (!stk.empty())
                {
                    s[stk.top()] = '*';
                    stk.pop();
                    break;
                }
            }
        }
        
        string ans;
        for (char &c : s)
            if (c != '*')
                ans.push_back(c);
        return ans;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(n∣Σ∣)，其中 n 是字符串 s 的长度，∣Σ∣ 为字符集合的大小，本题字符均为小写字母，所以 ∣Σ∣=26。

空间复杂度：O(n+∣Σ∣)，其中 n 是字符串 s 的长度，∣Σ∣ 为字符集合的大小，本题字符均为小写字母，所以 ∣Σ∣=26。

题目4：3171. 找到按位与最接近 K 的子数组

思路

位运算。

优化：

代码

/*
 * @lc app=leetcode.cn id=3171 lang=cpp
 *
 * [3171] 找到按位与最接近 K 的子数组
 */

// @lc code=start
class Solution
{
public:
    int minimumDifference(vector<int> &nums, int k)
    {
        int n = nums.size();
        int ans = INT_MAX;
        for (int i = 0; i < n; i++)
        {
            int x = nums[i];
            ans = min(ans, abs(x - k));
            for (int j = i - 1; j >= 0; j--)
            {
                if ((nums[j] & x) == nums[j])
                    break;
                nums[j] &= x;
                ans = min(ans, abs(nums[j] - k));
            }
        }
        return ans;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(nlogU)，其中 n 是数组 nums 的长度，U=max⁡(nums)。

空间复杂度：O(1)。