题目： 2357 使数组中所有元素都等于零

题面

给你一个非负整数数组 nums 。在一步操作中，你必须：

选出一个正整数 x ，x 需要小于或等于 nums 中 最小的非零元素。
nums 中的每个正整数都减去 x。
返回使 nums 中所有元素都等于 0 需要的 最少 操作数。

示例

示例 1：

输入：nums = [1,5,0,3,5]
输出：3
解释：
第一步操作：选出 x = 1 ，之后 nums = [0,4,0,2,4] 。
第二步操作：选出 x = 2 ，之后 nums = [0,2,0,0,2] 。
第三步操作：选出 x = 2 ，之后 nums = [0,0,0,0,0] 。
示例 2：

输入：nums = [0]
输出：0
解释：nums 中的每个元素都已经是 0 ，所以不需要执行任何操作。

Tips

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

Code

代码解释

这段 C++ 代码的目的是计算一个整数向量 nums 中，将所有非零元素变为 0 所需的最小操作次数。每次操作可以选择一个正整数 x，然后将 nums 中所有大于或等于 x 的元素减去 x。最终，这个问题可以转化为计算 nums 中不同非零整数的数量。

原始代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
public:
    int minimumOperations(vector<int>& nums) {
        vector<bool> dic(101, 0);
        int len = nums.size();
        for(int i = 0; i < len; i++){
            dic[nums[i]] = 1;
        }
        int res = 0;
        for(int i = 1; i < 101; i++){
            if(dic[i] == 1){
                res++;
            }
        }
        return res;
    }
};

逐行解释

1
2
class Solution {
public:
  • 这是 C++ 类 Solution 的定义开始，这是编程竞赛和平台（如 LeetCode）上常用的代码结构，用来封装解决方案。
1
int minimumOperations(vector<int>& nums) {
  • 定义了一个公共成员函数 minimumOperations，它接收一个整数向量 nums 作为引用参数，并返回一个整数结果。函数的目的是计算将 nums 中所有非零元素变为 0 所需的最小操作次数。
1
vector<bool> dic(101, 0);
  • 定义了一个大小为 101 的布尔类型向量 dic，并初始化为 0。这个向量用于记录 nums 中出现的数字，假设 nums 中的数字范围是 0 到 100。
1
int len = nums.size();
  • 获取 nums 向量的大小，并将其存储在 len 变量中。
1
2
3
for(int i = 0; i < len; i++){
    dic[nums[i]] = 1;
}
  • 这个 for 循环遍历 nums 向量的每一个元素。对于每个 nums[i]，将 dic[nums[i]] 设置为 1，表示该数字在 nums 中出现过。
1
int res = 0;
  • 定义了一个整数变量 res，并将其初始化为 0。这个变量将用于计数 nums 中不同非零整数的数量。
1
2
3
4
5
for(int i = 1; i < 101; i++){
    if(dic[i] == 1){
        res++;
    }
}
  • 这个 for 循环遍历从 1 到 100 的所有整数。对于每一个 i，如果 dic[i] 的值为 1，说明该整数在 nums 中出现过，则将 res 递增 1。这个过程计算了 nums 中不同非零整数的数量。
1
2
3
        return res;
    }
};
  • 最后，函数返回 res 的值，即 nums 向量中不同非零整数的数量。这个数量代表将 nums 中所有非零元素变为 0 所需的最少操作次数。类定义在此结束。

代码总结

这段代码的核心逻辑是使用布尔向量 dic 来记录 nums 中出现的每个非零整数，然后通过遍历 dic 来计算不同非零整数的数量。
这些不同的非零整数即表示需要进行的最小操作次数。代码的时间复杂度为 O(n)，其中 n 是 nums 向量的长度；
空间复杂度为 O(1)，因为 dic 向量的大小是固定的。