Leetcode 第 394 场周赛题解_leetcode周赛答案-优快云博客

Leetcode 第 394 场周赛题解

Leetcode 第 394 场周赛题解

Leetcode 第 394 场周赛题解

题目1：3120. 统计特殊字母的数量 I

思路

模拟。

用两个布尔类型的数组分别统计大写字符和小写字符的出现情况。

满足 lower[i] && upper[i] 成立，就是特殊字符。

代码

/*
 * @lc app=leetcode.cn id=3120 lang=cpp
 *
 * [3120] 统计特殊字母的数量 I
 */

// @lc code=start
class Solution
{
public:
    int numberOfSpecialChars(string word)
    {
        vector<bool> lower(26, 0), upper(26, 0);
        for (char &c : word)
        {
            if (islower(c))
                lower[c - 'a'] = true;
            else
                upper[c - 'A'] = true;
        }
        int cnt = 0;
        for (int i = 0; i < 26; i++)
            if (lower[i] && upper[i])
                cnt++;
        return cnt;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(n+|∑|)，其中 n 是字符串 word 的长度，|∑|是大（小）写字符集的大小，等于26。

空间复杂度：O(|∑|)，其中 |∑| 表示字符集的大小，大小写字母总共有52个。

题目2：3121. 统计特殊字母的数量 II

思路

模拟。

在第一题的基础上，用一个 lowerLastIdx 数组记录小写字符最后一次出现的下标，再用一个 upperFirstIdx 数组记录大写字符第一次出现的下标。

满足 lower[i] && upper[i] && lowerLastIdx[i] < upperFirstIdx[i] 成立，就是特殊字符。

代码

/*
 * @lc app=leetcode.cn id=3121 lang=cpp
 *
 * [3121] 统计特殊字母的数量 II
 */

// @lc code=start
class Solution
{
public:
    int numberOfSpecialChars(string word)
    {
        vector<bool> lower(26, 0), upper(26, 0);
        vector<int> lowerLastIdx(26, -1), upperFirstIdx(26, -1);
        for (int i = 0; i < word.size(); i++)
        {
            char c = word[i];
            if (islower(c))
            {
                lower[c - 'a'] = true;
                lowerLastIdx[c - 'a'] = i;
            }
            else
            {
                upper[c - 'A'] = true;
                if (upperFirstIdx[c - 'A'] == -1)
                    upperFirstIdx[c - 'A'] = i;
            }
        }
        int cnt = 0;
        for (int i = 0; i < 26; i++)
            if (lower[i] && upper[i] && lowerLastIdx[i] < upperFirstIdx[i])
                cnt++;
        return cnt;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(n+|∑|)，其中 n 是字符串 word 的长度，|∑|是大（小）写字符集的大小，等于26。

空间复杂度：O(|∑|)，其中 |∑| 表示字符集的大小，大小写字母总共有52个。

题目3：3122. 使矩阵满足条件的最少操作次数

思路

记忆化搜索。

要使得操作次数最少，我们反向思维，可以使保留的数字最多。

首先统计每一列的每种元素的出现次数到 cnt 数组中，其中 cnt[i][x] 表示第 i 列元素 x 的出现次数。

对于第 i 列，我们需要知道上一列都变成了什么数，比如上一列都变成了 1，那么第 i 列就必须都变成不等于 1 的数，比如 2，那么第 i 列就可以保留 cnt[i][2] 个元素不变。

枚举每一列变成哪个数，就可以枚举到所有的情况。

定义 dfs(i,j) 表示考虑前 i 列，且第 i+1 列都变成 j 时的最大保留不变元素个数。

用「枚举选哪个」思考。枚举第 i 列的元素都变成 k，则有

dfs(i,j)=max(dfs(i−1,k)+cnt[i][k])
在 [0,9] 中枚举不等于 j 的 k，取最大值即为 dfs(i,j)。

递归边界：dfs(−1,j)=0。

答案：mn−dfs(n−1,10)。注意初始 j 是一个不在 [0,9] 中的数。

代码

/*
 * @lc app=leetcode.cn id=3122 lang=cpp
 *
 * [3122] 使矩阵满足条件的最少操作次数
 */

// @lc code=start
class Solution
{
public:
    int minimumOperations(vector<vector<int>> &grid)
    {
        int m = grid.size(), n = m ? grid[0].size() : 0;
        // cnt[i][x] 表示第 i 列元素 x 的出现次数
        vector<vector<int>> cnt(n, vector<int>(10, 0));
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
            {
                int x = grid[i][j];
                cnt[j][x]++;
            }

        vector<vector<int>> memo(n, vector<int>(11, -1)); // -1 表示没有计算过
        function<int(int, int)> dfs = [&](int i, int j) -> int
        {
            if (i < 0)
                return 0;
            auto &res = memo[i][j]; // 注意这里是引用
            if (res != -1)
            { // 之前计算过
                return res;
            }
            res = 0;
            for (int k = 0; k < 10; k++)
            {
                if (k != j)
                    res = max(res, dfs(i - 1, k) + cnt[i][k]);
            }
            return res;
        };

        int maxRemain = dfs(n - 1, 10);
        return m * n - maxRemain;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(mn+nU²)，其中 m 和 n 分别是矩阵 grid 的行数和列数，U 为元素种类数，即 10。

空间复杂度：O(nU)，其中 n 是矩阵 grid 的列数，U 为元素种类数，即 10。

题目4：3123. 最短路径中的边

思路

题解：Dijkstra 最短路 + DFS/BFS 找边（Python/Java/C++/Go）

代码

/*
 * @lc app=leetcode.cn id=3123 lang=cpp
 *
 * [3123] 最短路径中的边
 */

// @lc code=start
class Solution
{
public:
    vector<bool> findAnswer(int n, vector<vector<int>> &edges)
    {
        int m = edges.size();
        // 建图
        vector<vector<tuple<int, int, int>>> g(n);
        for (int i = 0; i < m; i++)
        {
            vector<int> edge = edges[i];
            int x = edge[0], y = edge[1], w = edge[2];
            g[x].emplace_back(y, w, i);
            g[y].emplace_back(x, w, i);
        }

        // Dijkstra
        vector<long long> dis(n, LLONG_MAX);
        dis[0] = 0LL;
        priority_queue<pair<long long, int>, vector<pair<long long, int>>, greater<>> pq;
        pq.emplace(0, 0);
        while (!pq.empty())
        {
            auto [dx, x] = pq.top();
            pq.pop();
            if (dx > dis[x])
                continue;
            for (auto [y, w, _] : g[x])
            {
                int new_dis = dx + w;
                if (new_dis < dis[y])
                {
                    dis[y] = new_dis;
                    pq.emplace(new_dis, y);
                }
            }
        }

        vector<bool> ans(m, false);
        // 节点 0 到节点 n-1 不连通
        if (dis[n - 1] == LLONG_MAX)
            return ans;
        // 从终点出发 DFS
        vector<int> visited(n);
        function<void(int)> dfs = [&](int y)
        {
            visited[y] = true;
            for (auto &[x, w, i] : g[y])
            {
                if (dis[x] + w != dis[y])
                    continue;
                // dis[x] + w == dis[y]，说明边 x-y 在节点 0 到节点 n-1 的最短路上
                ans[i] = true;
                if (!visited[x])
                    dfs(x);
            }
        };
        dfs(n - 1);
        return ans;
    }
};
// @lc code=end