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

一、前言

分类：Divide and Conquer。

问题来源LeetCode 315 难度：困难。

问题链接：https://leetcode-cn.com/problems/count-of-smaller-numbers-after-self/

 

二、题目

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

示例1：

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

 

三、思路

提供两种解题方法。

方法一：二叉搜索。通过构建二叉树，可以判断出每个节点的左节点个数，左节点个数即为，小于该值的个数。

方法二：归并排序。在合并的过程中，当左边值小于右边值时，可以判断出此次合并右边有多少个小于该值的数。例如下图，8 < 26，此次合并中右边有小于8的数有3个。

 

四、编码实现

//==========================================================================
/*
* @file    : 315_CountSmaller.h
* @label   : Divide and Conquer
* @blogs   : https://blog.csdn.net/nie2314550441/article/details/107433972
* @author  : niebingyu
* @date    : 2020/07/18
* @title   : 315.计算右侧小于当前元素的个数
* @purpose : 给定一个整数数组 nums，按要求返回一个新数组 counts。数组 counts 有该性质：
* counts[i] 的值是  nums[i] 右侧小于 nums[i] 的元素的数量。
*
* 示例：
* 输入：[5,2,6,1]
* 输出：[2,1,1,0]
* 解释：
* 5 的右侧有 2 个更小的元素 (2 和 1)
* 2 的右侧仅有 1 个更小的元素 (1)
* 6 的右侧有 1 个更小的元素 (1)
* 1 的右侧有 0 个更小的元素
* 
*
* 来源：力扣（LeetCode）
* 难度：困难
* 链接：https://leetcode-cn.com/problems/count-of-smaller-numbers-after-self
*/
//==========================================================================
#pragma once
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <assert.h>
using namespace std;

#define NAMESPACE_COUNTSMALLER namespace NAME_COUNTSMALLER {
#define NAMESPACE_COUNTSMALLEREND }
NAMESPACE_COUNTSMALLER

// 方法一，二叉搜索
class Solution_1 
{
    struct BSTNode
    {
        int val;
        int cnt;  // 左子树的数目
        BSTNode* left;
        BSTNode* right;
        BSTNode(int x):val(x), cnt(0), left(NULL),right(NULL){}
    };

    void BST_insert(BSTNode* node, BSTNode* insert_node, int& num)
    {
        if(node->val >= insert_node->val)
        {
            node->cnt++;
            if(node->left)
                BST_insert(node->left, insert_node, num);
            else
                node->left = insert_node;
        }
        else
        {
            num += node->cnt + 1;
            if(node->right)
                BST_insert(node->right, insert_node, num);
            else    
                node->right = insert_node;
        }
    }

public:
    vector<int> countSmaller(vector<int>& nums) 
    {
        int n = nums.size();
        if(n == 0)
            return {};
        
        vector<int> count;
        count.push_back(0);
        
        BSTNode* node = new BSTNode(nums[n-1]);
        for(int i = n - 2; i >= 0; i--)
        {
            int num = 0;
            BSTNode* insert_node = new BSTNode(nums[i]);
            BST_insert(node, insert_node, num);
            count.push_back(num);
        }

        delete node;
        reverse(count.begin(), count.end());
        return count;
    }
};

// 方法二，归并排序
class Solution_2 
{
public:
    vector<int> countSmaller(vector<int> &nums)
    {
        if (!nums.size()) return {};
        vector<int> res(nums.size(), 0);
        for (int i = 0; i < nums.size(); i++)
        {
            temp.push_back(0);
            index.push_back(i);
        }

        merge(nums, 0, nums.size() - 1, res);
        return res;
    }

private:
    // 记录下标
    vector<int> index;
    vector<int> temp;

    void merge(vector<int> &nums, int l, int r, vector<int> &res)
    {
        if (l == r) return;
        int mid = (l + r) >> 1;
        merge(nums, l, mid, res);
        merge(nums, mid + 1, r, res);

        // 若数组本身有序，则提前终止
        if (nums[index[mid]] <= nums[index[mid + 1]])
            return;

        // 只需要赋值 index 数组的 [l, r] 这个子区间里的值
        for (int i = l; i <= r; ++i)
            temp[i] = index[i];

        int li = l, ri = mid + 1, j = l;
        while (li <= mid || ri <= r)
        {
            if (li > mid || (ri <= r && nums[temp[li]] > nums[temp[ri]]))
            {
                index[j] = temp[ri];
                ri++;
            }
            else
            {
                index[j] = temp[li]; 
                res[temp[li]] += ri - mid - 1;
                li++;
            }
            j++;
        }
    }
};

以下为测试代码//
// 测试 用例 START
void test(const char* testName, vector<int>& nums, vector<int> expect)
{
    Solution_1 s1;
    vector<int> result1 = s1.countSmaller(nums);

    Solution_2 s2;
    vector<int> result2 = s2.countSmaller(nums);

    if (result1 == expect && result2 == expect)
        cout << testName << ", solution passed." << endl;
    else
        cout << testName << ", solution failed. " << endl;
}

// 测试用例
void Test1()
{
    vector<int> nums = { 5,2,6,1 };
    vector<int> expect = { 2,1,1,0 };

    test("Test1()", nums, expect);
}

// 测试用例
void Test2()
{
    vector<int> nums = { 8, 12, 16, 22, 100, 7, 7, 7, 26, 55 };
    vector<int> expect = { 3,3,3,3,5,0,0,0,0,0 };

    test("Test2()", nums, expect);
}
NAMESPACE_COUNTSMALLEREND
// 测试 用例 END
//
void CountSmaller_Test()
{
    cout << "------ start 315.计算右侧小于当前元素的个数 ------" << endl;
    NAME_COUNTSMALLER::Test1();
    NAME_COUNTSMALLER::Test2();
    cout << "------ end 315.计算右侧小于当前元素的个数 --------" << endl;
}

执行结果：