【刷爆LeetCode】七月算法集训（24）线段树

最新推荐文章于 2024-03-04 21:08:37 发布

...1999

最新推荐文章于 2024-03-04 21:08:37 发布

阅读量388

点赞数

分类专栏：七月算法集训文章标签：算法 leetcode

本文链接：https://blog.csdn.net/LAdestiny/article/details/125963919

版权

七月算法集训专栏收录该内容

31 篇文章 0 订阅

订阅专栏

题目来源于知识星球—英雄算法联盟，七月算法集训专题

前言

跟随英雄算法联盟博主—英雄哪里出来，每天完成相应的算法练习，一个月后，必定会有所成长！

一、剑指 Offer 51.数组中的逆序对（困难）

1.题目描述

2.解题思路

下面提供了两种方法
第一种为暴力题解，直接遍历数组，符合题意则计数器++；（无奈超时，不要学习这种）
第二种方法采用线段树：
 1. 从后往前遍历所有数字，遍历某个数字之后，将其插入到一个容器中，在容器中
查询比这个数更小的数字的个数，累加得到逆序对数目；
 2. 将数字插入容器、查找容器中比当前数小的数字，可以使用线段树中的**单点插入**
和**区间求和**；
 3. 题目没有说明数据范围，因此要做一次离散化，将所有数字转换成连续序列，再进
行处理。

3.代码演示（C++）

方法一：暴力、数组遍历（错误做法，超时了ε=(´ο｀*)))唉）

class Solution 
{
public:
    int reversePairs(vector<int>& nums) 
    {
        int cnt=0;
        for(int i=0;i<nums.size()-1;i++)
        {
            for(int j=i+1;j<nums.size();j++)
            {
                if(nums[i]>nums[j])
                {
                    cnt++;
                }
            }
        }
        return cnt;
    }
};

方法二：线段树（正确做法，以后需要仔细研读）

class Solution 
{
    #define maxn 50010
    vector<int> val;
    int getIndex(int v) 
    {
        int l = 0, r = val.size() - 1;
        while(l <= r) 
        {
            int mid = (l + r) >> 1;
            if(v > val[mid]) 
            {
                l = mid + 1;
            }
            else if(v < val[mid]) 
            {
                r = mid - 1;
            }
            else 
            {
                return mid;
            }
        }
        return -1;
    }
    int getValue(int idx) 
    {
        return val[idx];
    }
    struct SegTreeNode 
    {
        int sum;
    }S[1<<17];
    void build(int p, int l, int r) 
    {
        if(l == r) 
        {
            S[p].sum = 0;
            return ;
        }
        int mid = (l + r) >> 1;
        build(p<<1, l, mid);
        build(p<<1|1, mid+1, r);
    }
    void insert(int p, int l, int r, int pos) 
    {
        if(pos < l || pos > r) 
        {
            return ;
        }
        if(l == r) 
        {
            S[p].sum++;
            return ;
        }
        int mid = (l + r) >> 1;
        insert(p<<1, l, mid, pos);
        insert(p<<1|1, mid+1, r, pos);
        S[p].sum = S[p<<1].sum + S[p<<1|1].sum;
    }
    void query(int p, int l, int r, int ql, int qr, int& ans) 
    {
        if(qr < l || ql > r) 
        {
            return ;
        }
        if(ql <= l && r <= qr) 
        {
            ans += S[p].sum;
            return ;
        }
        int mid = (l + r) >> 1;
        query(p<<1, l, mid, ql, qr, ans);
        query(p<<1|1, mid+1, r, ql, qr, ans);
    }
public:
    int reversePairs(vector<int>& nums) 
    {
        if(nums.size() == 0) 
        {
            return 0;
        }
        int i;
        for(i = 0; i < nums.size(); ++i) 
        {
            val.push_back(nums[i]);
        }
        sort(val.begin(), val.end());
        val.erase( unique(val.begin(), val.end()), val.end() );
        for(i = 0; i < nums.size(); ++i) 
        {
            nums[i] = getIndex(nums[i]);
        }
        int L = 0, R = nums.size() - 1;
        int sum = 0;
        for(i = R; i >= 0; --i) 
        {
            int ans = 0;
            query(1, L, R, 0, nums[i]-1, ans);
            sum += ans;
            insert(1, L, R, nums[i]);
        }
        return sum;
    }
};