力扣 480. 滑动窗口中位数 划分树 Treap

https://leetcode-cn.com/problems/sliding-window-median/

思路一：需要一种可以快速求出区间第$k$大的数据结构，那么主席树、$Treap$等都满足题意，这里我用了划分树，他也可以求出区间第$k$大，不过不支持动态修改，详见我这篇博客。

class DivideTree
{
public:
    DivideTree(vector<int>& nums):vec(nums)
    {
        tree.emplace_back(nums);
        sort(vec.begin(),vec.end());
        build(0,0,vec.size()-1);
    }

    void build(int depth,int l,int r)
    {
        if(l==r)
            return ;
        if(tree.size()<=depth+1)
            tree.emplace_back(vector<int>(vec.size()));
        if(num.size()<=depth)
            num.emplace_back(vector<int>(vec.size()));
        int mid=(l+r)>>1,mid_value=vec[mid];
        int lidx=l,ridx=mid+1,lnum=0;
        for(int i=l;i<=mid;i++)
            if(vec[i]==mid_value)
                ++lnum;
        for(int i=l;i<=r;i++)
        {
            if(i==l)
                num[depth][i]=0;
            else
                num[depth][i]=num[depth][i-1];
            if(tree[depth][i]==mid_value)
            {
                if(lnum)
                {
                    --lnum;
                    tree[depth+1][lidx++]=mid_value;
                    ++num[depth][i];
                }
                else
                    tree[depth+1][ridx++]=mid_value;
            }
            else if(tree[depth][i]<mid_value)
            {
                tree[depth+1][lidx++]=tree[depth][i];
                ++num[depth][i];
            }
            else
                tree[depth+1][ridx++]=tree[depth][i];
        }
        build(depth+1,l,mid);
        build(depth+1,mid+1,r);
    }

    int query(int l,int r,int k)
    {
        return _query(0,0,vec.size()-1,l,r,k);
    }

    int _query(int depth,int l,int r,int ql,int qr,int k)
    {
        if(l==r)
            return tree[depth][l];
        int cntl,cntr,mid=(l+r)>>1;
        if(l==ql)
            cntl=0;
        else
            cntl=num[depth][ql-1];
        cntr=num[depth][qr];
        if(k<=cntr-cntl)
            return _query(depth+1,l,mid,l+cntl,l+cntr-1,k);
        else
            return _query(depth+1,mid+1,r,mid+1+ql-l-cntl,mid+1+qr-l-cntr,k-cntr+cntl);
    }
private:
    vector<vector<int>> tree;
    vector<vector<int>> num;
    vector<int> vec;
};

class Solution {
public:

    vector<double> medianSlidingWindow(vector<int>& nums, int k) {
        vector<double> ans;
        DivideTree tree(nums);
        int n=nums.size();
        int mid=k>>1;
        for(int i=k-1;i<n;i++)
        {
            if(k&1)
                ans.emplace_back(tree.query(i-k+1,i,mid+1));
            else
                ans.emplace_back((tree.query(i-k+1,i,mid)*1.0+tree.query(i-k+1,i,mid+1))/2);
        }
        return ans;
    }
};

思路二：直接上$Treap$，不会的可以看我这篇博客。

class Treap
{
public:
    int rt;

    Treap(int n):rt(0),sz(0),ans(0)
    {
        ++n;
        lson.resize(n),rson.resize(n),val.resize(n),rnd.resize(n),siz.resize(n),eql.resize(n);
        srand(time(NULL));
    }

    void insert(int &idx,int v)
    {
        if(!idx)
        {
            idx=++sz;
            siz[idx]=eql[idx]=1;
            val[idx]=v;
            rnd[idx]=rand();
            return;
        }
        siz[idx]++;
        if(val[idx]==v)
            ++eql[idx];
        else if(val[idx]<v)
        {
            insert(rson[idx],v);
            if(rnd[rson[idx]]<rnd[idx])
                leftRotate(idx);
        }
        else
        {
            insert(lson[idx],v);
            if(rnd[lson[idx]]<rnd[idx])
                rightRotate(idx);
        }
    }

    void del(int &idx,int v)
    {
        if(!idx)
            return;
        if(val[idx]==v)
        {
            if(eql[idx]>1)
            {
                --siz[idx],--eql[idx];
                return;
            }
            if(!lson[idx]||!rson[idx])
                idx=lson[idx]+rson[idx];
            else if(rnd[lson[idx]]<rnd[rson[idx]])
            {
                rightRotate(idx);
                del(idx,v);
            }
            else
            {
                leftRotate(idx);
                del(idx,v);
            }
        }
        else if(val[idx]<v)
        {
            --siz[idx];
            del(rson[idx],v);
        }
        else
        {
            --siz[idx];
            del(lson[idx],v);
        }
    }

    int queryNum(int idx,int rk)
    {
        if(!idx)
            return 0;
        if(rk<=siz[lson[idx]])
            return queryNum(lson[idx],rk);
        else if(rk>siz[lson[idx]]+eql[idx])
            return queryNum(rson[idx],rk-siz[lson[idx]]-eql[idx]);
        return val[idx];
    }

private:
    int ans,sz;
    vector<int> lson,rson,val,rnd,siz,eql;

    void modifySize(int idx)
    {
        siz[idx]=siz[lson[idx]]+siz[rson[idx]]+eql[idx];
    }

    void leftRotate(int &idx)
    {
        int r=rson[idx];
        rson[idx]=lson[r];
        lson[r]=idx;
        siz[r]=siz[idx];
        modifySize(idx);
        idx=r;
    }

    void rightRotate(int &idx)
    {
        int l=lson[idx];
        lson[idx]=rson[l];
        rson[l]=idx;
        siz[l]=siz[idx];
        modifySize(idx);
        idx=l;
    }
};


class Solution {
public:

    vector<double> medianSlidingWindow(vector<int>& nums, int k) {
        vector<double> ans;
        int n=nums.size();
        Treap tree(n);
        int mid=k>>1;
        for(int i=0;i<n;i++)
        {
            tree.insert(tree.rt,nums[i]);
            if(i>=k-1)
            {
                if(k&1)
                    ans.emplace_back(tree.queryNum(tree.rt,mid+1));
                else
                    ans.emplace_back((tree.queryNum(tree.rt,mid)*1.0+tree.queryNum(tree.rt,mid+1))/2);
                tree.del(tree.rt,nums[i-k+1]);
            }
        }
        return ans;
    }
};

思路三：两个堆+延迟删除。感觉这个还是比较麻烦的，不过思想值得学习……简而言之就是用两个堆来维护序列，用一个大根堆维护较小的$\frac{k}{2}+1$个元素，然后用一个小根堆维护较大的$\frac{k}{2}$个元素，这样就很容易得到序列的中位数了。最重要的是延迟删除怎么实现？我们可以用一个哈希表，$h[i]=v$表示$i$这个数需要删除$v$次，然后写一个$check$函数判断当前堆顶的元素是否需要删除……那么在什么时候需要调用$check$函数呢？因为我们经常需要进行$top()$操作，所以一定要保证在进行这些操作前堆顶元素不是需要被删除的，所以当我们在逻辑上修改某个堆的元素个数时，要调用这个函数；在弹出堆顶元素后，也要调用这个函数（就是这两点让我wa了半天 艹）。具体看代码吧，或者看官方题解，细节太多不想赘述了。

class DualHeap
{
public:
    priority_queue<int> maxq;
    priority_queue<int,vector<int>,greater<int>> minq;
    map<int,int> delay;
    int max_siz=0,min_siz=0,myk=0;

    DualHeap(int k):myk(k){}

    template<typename T>
    void checkHeapTop(T &heap)
    {
        while(!heap.empty())
        {
            int val=heap.top();
            if(delay.find(val)==delay.end())
                break;
            else
            {
                if(--delay[val]==0)
                    delay.erase(val);
                heap.pop();
            }
        }
    }

    void balance()
    {
        if(max_siz>min_siz+1)
        {
            --max_siz;
            ++min_siz;
            minq.push(maxq.top());
            maxq.pop();
            checkHeapTop(maxq);
        }
        else if(max_siz<min_siz)
        {
            ++max_siz;
            --min_siz;
            maxq.push(minq.top());
            minq.pop();
            checkHeapTop(minq);
        }
    }

    void push(int val)
    {
        if(maxq.empty()||val<=maxq.top())
            ++max_siz,maxq.push(val);
        else
            ++min_siz,minq.push(val);
        balance();
    }

    void erase(int val)
    {
        ++delay[val];
        if(val<=maxq.top())
            --max_siz,checkHeapTop(maxq);
        else
            --min_siz,checkHeapTop(minq);
        balance();
    }

    double getMedian()
    {
        if(myk&1)
            return maxq.top();
        else
            return (maxq.top()*1.0+minq.top())/2;
    }
};

class Solution {
public:

    vector<double> medianSlidingWindow(vector<int>& nums, int k) {
        vector<double> ans;
        DualHeap heap(k);
        for(int i=0;i<k;i++)
            heap.push(nums[i]);
        ans.emplace_back(heap.getMedian());
        int n=nums.size();
        for(int i=k;i<n;i++)
        {
            heap.push(nums[i]);
            heap.erase(nums[i-k]);
            ans.emplace_back(heap.getMedian());
        }
        return ans;
    }
};