leetcode 3080

news2024/11/18 19:36:59

leetcode 3080

题目

在这里插入图片描述

例子

在这里插入图片描述

思路

创建数组，记录nums 的值对应的id, 按照大小排序。

代码实现

class Solution {
public:
    vector<long long> unmarkedSumArray(vector<int>& nums, vector<vector<int>>& queries) {

        vector<long long> res;
        int n = nums.size();
        /*
        ids 数组是为了记录nums的val的index的序列。
        举个例子：
        nums = [1,2,2,1,2,3,1]
        ids[0] [1] [2] 对应的值是0, 3, 6
        因为nums[0], nums[3], nums[6] 的值都是1，是最小值；
        */
        vector<int> ids(n);
        iota(ids.begin(), ids.end(), 0);
        ranges::stable_sort(ids, [&](int i, int j) { return nums[i] < nums[j]; });
        
        for(int i=0; i<queries.size(); i++){
            int q_id = queries[i][0];
            int q_num = queries[i][1];

            // 被标记的id 的nums的值，设置为0， 这样计算sum 的时候，直接默认标记了。
            // 已知nums 是正整数数组，正整数的范围是 >0 的。

            nums[q_id] = 0;

            int j =0;
            while(q_num > 0 && j<n){
                int num_id = ids[j];
                
                if(nums[num_id] == 0){
                    j++;
                }else{
                    nums[num_id] = 0;
                    q_num--;
                    j++;
                }
            }

            long long sum = std::accumulate(nums.begin(), nums.end(), 0);
            res.push_back(sum);
        }

        return res;
        
    }
};

long long sum = std::accumulate(nums.begin(), nums.end(), 0LL);

解决了runtime error , 还是有超时问题。

在这里插入图片描述

class Solution {
public:
    vector<long long> unmarkedSumArray(vector<int>& nums, vector<vector<int>>& queries) {

        vector<long long> res;
        int n = nums.size();
        long long sum = std::accumulate(nums.begin(), nums.end(), 0LL);
        /*
        ids 数组是为了记录nums的val的index的序列。
        举个例子：
        nums = [1,2,2,1,2,3,1]
        ids[0] [1] [2] 对应的值是0, 3, 6
        因为nums[0], nums[3], nums[6] 的值都是1，是最小值；
        */
        vector<int> ids(n);
        iota(ids.begin(), ids.end(), 0);
        ranges::stable_sort(ids, [&](int i, int j) { return nums[i] < nums[j]; });
        
        int j =0;
        for(int i=0; i<queries.size(); i++){
            int q_id = queries[i][0];
            int q_num = queries[i][1];

            // 被标记的id 的nums的值，设置为0， 这样计算sum 的时候，直接默认标记了。
            // 已知nums 是正整数数组，正整数的范围是 >0 的。
            sum = sum - nums[q_id];
            nums[q_id] = 0;
            
            while(q_num > 0 && j<n){
                int num_id = ids[j];
                
                if(nums[num_id] > 0){
                    sum = sum - nums[num_id];
                    nums[num_id] = 0;
                    q_num--;
                }
                j++;
            }            
            res.push_back(sum);
        }

        return res;
        
    }
};

减少while or loop 里的计算or 判断，可以减少执行时间。

分析

时间复杂度：
O(nlogn)
stable_sort 的时间复杂度是nlogn;
stable_sort 使用的是归并排序；
对于递归方程 T(n) = 2T(n/2) + O(n)，我们可以通过分析归并排序的算法流程来推导出时间复杂度为 O(n log n)。

根据递归方程 T(n) = 2T(n/2) + O(n)，我们可以得到以下递归树：

        T(n)
       /     \
   T(n/2)   T(n/2)
   /   \     /   \
T(n/4) T(n/4) T(n/4) T(n/4)

递归树的每一层的时间复杂度为 O(n)，因为每层的合并操作需要线性时间。
递归树的高度为 log n，因为每次将序列一分为二，直到子序列只有一个元素。
在递归树的每一层，都有 O(n) 的合并操作，总共有 log n 层，因此总的时间复杂度为 O(n log n)。

综上所述，通过对递归方程和递归树的分析，可以得出归并排序的时间复杂度为 O(n log n)。

希望这个解释能够帮助您理解如何从递归方程推导出时间复杂度为 O(n log n)。如果您有任何其他问题，请随时告诉我。

空间复杂度：
O(n)

stable_sort 函数

对于 ranges::stable_sort(ids, [&](int i, int j) { return nums[i] < nums[j]; }); 这样的调用方式，我们可以简单地了解其实现原理。由于 ranges::stable_sort 是 C++20 中引入的新函数，其具体实现可能会因标准库的不同而有所差异。以下是一个简单的伪代码示例，展示了 ranges::stable_sort 的可能实现：

template <class RandomAccessIterator, class Compare>
void ranges::stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp) {
    if (first == last) return;
    
    using value_type = typename std::iterator_traits<RandomAccessIterator>::value_type;
    std::vector<value_type> temp(first, last); // 将范围内的元素复制到临时数组中
    
    // 使用 lambda 表达式作为比较函数
    auto lambda_comp = [&](int i, int j) { return comp(temp[i], temp[j]); };
    
    std::stable_sort(temp.begin(), temp.end(), lambda_comp); // 使用 std::stable_sort 对临时数组进行排序
    
    std::copy(temp.begin(), temp.end(), first); // 将排序后的元素复制回原始范围
}

上述伪代码简单地描述了 ranges::stable_sort 的实现思路。首先，将范围内的元素复制到临时数组中，然后使用 lambda 表达式作为比较函数，对临时数组进行排序，最后将排序后的元素复制回原始范围。这种实现方式保证了稳定排序的特性。

需要注意的是，实际的 ranges::stable_sort 实现可能会更加复杂，因为它需要考虑范围操作、迭代器特性、元素类型等多个因素。

accumulate 函数

std::accumulate 是 C++ 标准库中的一个算法函数，用于对一个范围内的元素进行累积操作。它定义在 <numeric> 头文件中。

std::accumulate 函数的原型如下：

template< class InputIt, class T >
T accumulate( InputIt first, InputIt last, T init );

其中：

InputIt 是输入迭代器的类型，用于指定范围的开始和结束位置。
T 是累积结果的类型，也是初始值的类型。
first 和 last 分别是指向范围的起始和结束位置的迭代器。
init 是初始值，用于初始化累积结果。

std::accumulate 函数会从 first 到 last 遍历范围内的元素，对它们进行累积操作。具体而言，它将初始值 init 和范围内的每个元素进行二元操作（通常是加法），并将结果存储在累积结果中。最终返回累积结果。

以下是一个示例用法：

#include <iostream>
#include <vector>
#include <numeric>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用 std::accumulate 函数计算和
    int sum = std::accumulate(vec.begin(), vec.end(), 0);

    std::cout << "Sum of elements in the vector: " << sum << std::endl;

    return 0;
}