leetcode 315. 计算右侧小于当前元素的个数—(每日一难day7)_r程序请按要求返回一个新数组 counts。数组 counts 有该性质: counts[i]的值

315. 计算右侧小于当前元素的个数

给你一个整数数组 nums ，按要求返回一个新数组 counts 。数组 counts 有该性质： counts[i] 的值是 nums[i] 右侧小于 nums[i] 的元素的数量。

示例 1：

输入：nums = [5,2,6,1]
输出：[2,1,1,0]
解释：
5 的右侧有 2 个更小的元素 (2 和 1)
2 的右侧仅有 1 个更小的元素 (1)
6 的右侧有 1 个更小的元素 (1)
1 的右侧有 0 个更小的元素

示例 2：

输入：nums = [-1]
输出：[0]

示例 3：

输入：nums = [-1,-1]
输出：[0,0]

提示：

1 <= nums.length <= 1e5
-1e4 <= nums[i] <= 1e4

解析

• 首先，可以想到暴力做法，每次遍历一个元素，就把当前元素后边所有元素遍历一遍，找到比当前元素小的元素个数。
• 其次，还有一种做法，从后往前遍历，将遍历过的元素存储下来（map），然后遍历当前存储下来的元素即可，这样可以消除重复元素。例如：如果元素的范围很小0-9，那么遍历一遍访问过的元素复杂度不过是O(10n). 可以参考这个题目
• 另外，就是利用树状数组的做法，详解如下：
  例如：nums 7 6 6 5 1
  创建一个数组 1 2 3 4 5 6 7 记录每个数已经出现的次数

每遍历一个元素只需要求当前元素的前缀和即可。显然这样会有两个问题

1. 数据范围过大，计数数组会过大，浪费空间，可以使用离散化解决这个问题。可以参考题目离散化题目
2. 每次遍历一个元素这个前缀和就会更新，因此可以使用树状数组解决这个问题。树状数组可以解决动态前缀和问题。可以参考 树状数组 视频讲解

code

class Solution {
public:
	// 用于离散化
    map<int,int> ma,idx;
    int f[100005];
    int lowbit(int p){
        return p&(-p);
    }
    //查询前缀和
    int query(int p){
        int res=0;
        while(p){
            res+=f[p];
            p-=lowbit(p);
        }
        return res;
    }
    // 更新前缀和
    void update(int p,int v){
        while(p<100005){
            f[p]+=v;
            p+=lowbit(p);
        }
    }
    vector<int> countSmaller(vector<int>& nums) {
        int n=nums.size();
        vector<int> res;
        // 离散化
        for(auto a : nums){
            ma[a]=1;
        }
        // 记录当前元素对应的新位置
        // 不使用0位置，防止越界，小技巧，
        // 对树状数组没有影响，相当于0位置为0
        int cnt=0;
        for(auto a :ma){
            idx[a.first]=++cnt;
        }
        // 从其那往后遍历，维护树状数组
        for(int i=n-1;i>=0;i--){
            res.push_back(query(idx[nums[i]]-1));
            update(idx[nums[i]],1);
        }
		// 也可以先将nums反转，从前往后遍历
        reverse(res.begin(),res.end());
        return res;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48