力扣第455场周赛

关注

原创 2025-07-01 22:34:20 1.1k 阅读 AI 写同款· GEO 优化 ›

【算法刷题指南】从零开始的LeetCode系统训练（持续更新 & 分类索引）本文提供了一份从零开始的LeetCode系统刷题指南，帮助读者建立算法思维体系。通过分类训练、模板化解题技巧和错题本管理，有效提升算法能力。涵盖哈希、双指针、滑动窗口、二叉树、回溯、动态规划等核心模块，适合准备大厂面试的开发者。阅读详情

Q1. 检查元素频次是否为质数

给你一个整数数组 nums。

如果数组中任一元素的频次是质数，返回 true；否则，返回 false。

元素 x 的频次是它在数组中出现的次数。

质数是一个大于 1 的自然数，并且只有两个因数：1 和它本身。

示例 1：

输入： nums = [1,2,3,4,5,4]

输出： true

解释：

数字 4 的频次是 2，而 2 是质数。

示例 2：

输入： nums = [1,2,3,4,5]

输出： false

解释：

所有元素的频次都是 1。

示例 3：

输入： nums = [2,2,2,4,4]

输出： true

解释：

数字 2 和 4 的频次都是质数。

提示：

1 <= nums.length <= 100
0 <= nums[i] <= 100

class Solution {
public:
    bool solve(int num){
        for(int i=2;i<=sqrt(num);i++){
            if(num%i==0) return false;
        }
        return true;
    }
    bool checkPrimeFrequency(vector<int>& nums) {
        unordered_map<int,int> mp;
        for(auto& x:nums){
            mp[x]++;
        }
        for(auto& x:mp){
            int n=x.second;
            if(solve(n)&&(n>=2)) return true;
        }
        return false;
    }
};

Q2. 硬币面值还原

给你一个从 1 开始计数的整数数组 numWays，其中 numWays[i] 表示使用某些固定面值的硬币（每种面值可以使用无限次）凑出总金额 i 的方法数。每种面值都是一个正整数，并且其值最多为 numWays.length。

然而，具体的硬币面值已经丢失。你的任务是还原出可能生成这个 numWays 数组的面值集合。

返回一个按从小到大顺序排列的数组，其中包含所有可能的唯一整数面值。

如果不存在这样的集合，返回一个空数组。

示例 1：

输入： numWays = [0,1,0,2,0,3,0,4,0,5]

输出： [2,4,6]

class Solution {
public:
    vector<int> findCoins(vector<int>& numWays) {
        int n=numWays.size();
        vector<int> dp(n+1,0);
        dp[0]=1;
        vector<int> res;
        for(int i=1;i<=n;i++){
            int cur=dp[i];
            int tar=numWays[i-1];
            if(cur>tar) return {};
            if(cur==tar) continue;
            if(cur+1==tar){
                res.push_back(i);
                for(int j=i;j<=n;j++){
                    dp[j]+=dp[j-i];
                }
            }else{
                return {};
            }
        }
        return res;
    }
};
// numWays[i]和i+1/numWays[i-1]和i
// 已知方法数, 求是由那些硬币构成的©leetcode

Q3. 使叶子路径成本相等的最小增量

给你一个整数 n，以及一个无向树，该树以节点 0 为根节点，包含 n 个节点，节点编号从 0 到 n - 1。这棵树由一个长度为 n - 1 的二维数组 edges 表示，其中 edges[i] = [ui, vi] 表示节点 ui 和节点 vi 之间存在一条边。
每个节点 i 都有一个关联的成本 cost[i]，表示经过该节点的成本。

路径得分定义为路径上所有节点成本的总和。

你的目标是通过给任意数量的节点增加成本（可以增加任意非负值），使得所有从根节点到叶子节点的路径得分相等。

返回需要增加成本的节点数的最小值。

示例 1：

输入： n = 3, edges = [[0,1],[0,2]], cost = [2,1,3]

输出： 1

using pii=pair<int,int>;
class Solution {
public:
    int minIncrease(int n, vector<vector<int>>& edges, vector<int>& cost) {
        vector<vector<int>> g(n);
        for(auto& e:edges){
            g[e[0]].push_back(e[1]);
            g[e[1]].push_back(e[0]);
        }
        function<pii(int,int)> dfs=[&](int u, int p)->pii{
            bool is_leaf=true;
            int maxSum=0;
            int total_adds=0;
            vector<pii> ch;
            for(int v:g[u]){
                if(v==p) continue;
                is_leaf=false;
                auto[sum_v,adds_v]=dfs(v,u);
                maxSum=max(maxSum,sum_v);
                ch.push_back({sum_v,adds_v});
            }
            if(is_leaf) return {cost[u],0};
            for(auto& c: ch){
                auto [sum_v, adds_v]=c;
                if (sum_v<maxSum){
                    total_adds+=adds_v+1;
                } else {
                    total_adds += adds_v;
                }

            }
            return {cost[u]+maxSum,total_adds};
        };
        auto [_, ans]=dfs(0,-1);
        return ans;
    } 
};

Q4. 所有人渡河所需的最短时间

有 n 名人员在一个营地，他们需要使用一艘船过河到达目的地。这艘船一次最多可以承载 k 人。渡河过程受到环境条件的影响，这些条件以周期性的方式在 m 个阶段内变化。
每个阶段 j 都有一个速度倍率 mul[j]：

如果 mul[j] > 1，渡河时间会变长。
如果 mul[j] < 1，渡河时间会缩短。
每个人 i 都有一个划船能力，用 time[i] 表示，即在中性条件下（倍率为 1 时）单独渡河所需的时间（以分钟为单位）。

规则：

从阶段 j 出发的一组人 g 渡河所需的时间（以分钟为单位）为组内成员的最大 time[i]，乘以 mul[j] 。
该组人渡河所需的时间为 d，阶段会前进 floor(d) % m 步。
如果还有人留在营地，则必须有一人带着船返回。设返回人的索引为 r，返回所需时间为 time[r] × mul[current_stage]，记为 return_time，阶段会前进 floor(return_time) % m 步。
返回将所有人渡河所需的最少总时间。如果无法将所有人渡河，则返回 -1。

示例 1：

输入： n = 1, k = 1, m = 2, time = [5], mul = [1.0,1.3]

输出： 5.00000

解释：

第 0 个人从阶段 0 出发，渡河时间 = 5 × 1.00 = 5.00 分钟。
所有人已经到达目的地，因此总时间为 5.00 分钟。
示例 2：

输入： n = 3, k = 2, m = 3, time = [2,5,8], mul = [1.0,1.5,0.75]

输出： 14.50000

解释：

最佳策略如下：

第 0 和第 2 个人从阶段 0 出发渡河，时间为 max(2, 8) × mul[0] = 8 × 1.00 = 8.00 分钟。阶段前进 floor(8.00) % 3 = 2 步，下一个阶段为 (0 + 2) % 3 = 2。
第 0 个人从阶段 2 独自返回营地，返回时间为 2 × mul[2] = 2 × 0.75 = 1.50 分钟。阶段前进 floor(1.50) % 3 = 1 步，下一个阶段为 (2 + 1) % 3 = 0。
第 0 和第 1 个人从阶段 0 出发渡河，时间为 max(2, 5) × mul[0] = 5 × 1.00 = 5.00 分钟。阶段前进 floor(5.00) % 3 = 2 步，最终阶段为 (0 + 2) % 3 = 2。
所有人已经到达目的地，总时间为 8.00 + 1.50 + 5.00 = 14.50 分钟。
示例 3：

输入： n = 2, k = 1, m = 2, time = [10,10], mul = [2.0,2.0]

输出： -1.00000

解释：

由于船每次只能载一人，因此无法将两人全部渡河，总会有一人留在营地。因此答案为 -1.00。

提示：

1 <= n == time.length <= 12
1 <= k <= 5
1 <= m <= 5
1 <= time[i] <= 100
m == mul.length
0.5 <= mul[i] <= 2.0

class Solution {
public:
    double minTime(int n, int k, int m, vector<int>& time, vector<double>& mul) {
        int u = 1 << n;
        vector<int> max_time(u);
        for (int i = 0; i < n; i++) {
            int t = time[i];
            int high_bit = 1 << i;
            for (int mask = 0; mask < high_bit; mask++) {
                max_time[high_bit | mask] =
                    max({max_time[high_bit | mask], max_time[mask], t});
            }
        }
        for (int i = 0; i < u; i++) {
            if (__builtin_popcount(i) > k) {
                max_time[i] = INT_MAX;
            }
        }
        vector dis(m, vector<double>(u, INT_MAX));
        priority_queue<tuple<double, int, int>, vector<tuple<double, int, int>>, greater<>> pq;
        auto push = [&](double d, int stage, int mask) {
            if (d < dis[stage][mask]) {
                dis[stage][mask] = d;
                pq.emplace(d, stage, mask);
            }
        };
        push(0, 0, u - 1); // 起点河岸
        while (!pq.empty()) {
            auto [d, stage, left] = pq.top();
            pq.pop();
            if (left == 0) {
                return d;
            }
            if (d > dis[stage][left]) {
                continue;
            }
            for (int sub = left; sub > 0; sub = (sub - 1) & left) {
                if (max_time[sub] == INT_MAX) {
                    continue;
                }
                double cost = max_time[sub] * mul[stage];
                int cur_stage = (stage + int(cost)) % m;
                if (sub == left) {
                    push(d + cost, cur_stage, 0);
                    continue;
                }
                for (int s = (u - 1) ^ left ^ sub, lb; s > 0; s ^= lb) {
                    lb = s & -s;
                    double return_time = max_time[lb] * mul[cur_stage];
                    push(d + cost + return_time, (cur_stage + int(return_time)) % m, left ^ sub ^ lb);
                }
            }
        }
        return -1;
    }
};
// 1. floor(d) % m  -> 阶段前进
// 把来回渡河一次所用的时间为边
// 单次渡河所用时间为：渡河集合中最大的time[i]
// 每个阶段枚举需要渡河的人,