BZOJ 3489 A simple rmq problem（KD-Tree解法）

最新推荐文章于 2020-01-15 17:03:21 发布

alpc_qleonardo

最新推荐文章于 2020-01-15 17:03:21 发布

阅读量365

点赞数

分类专栏： ------------数据结构----------- KD_Tree ---------Online Judge-------- BZOJ 文章标签： KD-Tree 数据结构 BZOJ

本文链接：https://blog.csdn.net/u013534123/article/details/80980312

版权

---------Online Judge-------- 同时被 3 个专栏收录

329 篇文章 0 订阅

订阅专栏

------------数据结构-----------

97 篇文章 1 订阅

订阅专栏

BZOJ

29 篇文章 0 订阅

订阅专栏

3489: A simple rmq problem

Time Limit: 40 Sec Memory Limit: 512 MB
Submit: 2683 Solved: 911
[ Submit][ Status][ Discuss]

Description

因为是OJ上的题，就简单点好了。给出一个长度为n的序列，给出M个询问：在[l,r]之间找到一个在这个区间里只出现过一次的数，并且要求找的这个数尽可能大。如果找不到这样的数，则直接输出0。我会采取一些措施强制在线。

Input

第一行为两个整数N,M。M是询问数，N是序列的长度（N<=100000，M<=200000)

第二行为N个整数，描述这个序列{ai}，其中所有1<=ai<=N

再下面M行，每行两个整数x，y，

询问区间[l,r]由下列规则产生（OIER都知道是怎样的吧>_<)：

l=min(（x+lastans)mod n+1,(y+lastans）mod n+1);

r=max(（x+lastans)mod n+1,(y+lastans）mod n+1);

Lastans表示上一个询问的答案，一开始lastans为0

Output

一共M行，每行给出每个询问的答案。

Sample Input

10 10

6 4 9 10 9 10 9 4 10 4

3 8

10 1

3 4

9 4

8 1

7 8

2 9

1 1

7 3

9 9

Sample Output

4

10

10

0

0

10

0

4

0

4

HINT

注意出题人为了方便，input的第二行最后多了个空格。

2015.6.24新加数据一组，2016.7.9放至40S,600M,但未重测

Source

by zhzqkkk

中文题，题意就不说了。

要求是求在一个区间里面只出现一次的最大的数字。这个和上一篇那个cf的题目很类似，但是那个是弱化版，只需要输出其中任意一个数字即可，而且这题要强制在线。

我们可以这么考虑，对于每一个数字，他可以有一个上一个出现的位置pre和下一个出现的位置nxt，再加上他自己的位置i，可以构成一个三维空间，坐标是（i,pre,nxt）。那么显然，对于一个询问[l,r]，如果要符合条件的话，pre要小于l，nxt要大于r，同时i要在l、r之间。那么这样，转化到三维空间中，满足条件的空间就是点(l,0,nxt+1)与点(r,l-1,INF)构成的一个长方体区域。这样，答案的话就是这个满足条件的空间中数值的最大值。

于是问题就变成了，维护一个三维空间的区间立方体的最大值。朴素的想法是利用三维线段树，但是这个实际上时空复杂度都很高，会到N(logN)^3。这都不是重点，重点是编程复杂度也很高，代码估计回彪到快150以上快200行。所以说得想一些其他的更快点的方法。

这里由于维度已经较高，我么可以考虑用KD树去解决这个问题。前面两篇已经讲过KD树的构建以及解决KNN问题的方法。但是作为一种数据结构，它的本意绝不仅是为了解决特定问题而存在，基本的存储维护数据的功能还是会有的。KD树同样也可以解决区间维护的问题。KD树的结构可以说是线段树和平衡树的结合，一方面非叶子节点本身也保存着一个点的信息，另一方面左右儿子又分别可以代表两个线段区间。为了解决区间问题，我们在以前的基础上，每个点加上两个l[]和r[]，表示当前以及他的后代节点在每一个维度上的范围。能够表示范围，那么也就可以在这个节点上维护这个范围内的最大值。这一点与线段树类似，再次不一一赘述。

然后具体说一说如何选取极值。对于线段树，我们是把询问区间步步分割，然后往下找，直到找到一个相同的区间然后返回这个区间的极值即可。但是，之前说个，KD树结构是平衡树与线段树的结合，所以说KD树的区间其实并不是包含所有的区间，也即可能某个点的区间是[1,10]，但它可以没有区间为[6,7]的后代，这也就保证了它的范围可以取很大，空间大小不受区间的影响而只与点的个数相关。因此，找不到相同区间，我们只能判断点与询问区间的包含关系，如果当前点被询问区间包含，那么更新极值。然后再看两个儿子表示的区间是否与询问区间相交，如果相交那么要对该区间搜索。

这样看来，这个查询极值的过程就和暴力没什么区别了，所以说得加一些显而易见的剪枝。首先，是如果某一个区间的极值不如当前最优解优，那么这个区间可以抛弃不搜索。其次，顺序问题，一个节点的两个儿子，我先搜索区间极值更优的那个，这样可能可以少搜索一个儿子。另外，这个区间表示也可以否掉很多区间，然后可以证明，对于K维N个点的KD树，搜索极值的复杂度是O(N^(K-1)/K)。对于本题的数据，40s的时间限制，最后在15s左右可以通过。具体见代码：

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define N 100010
#define K 3

using namespace std;

int idx,n,q,k=3,pos[N];

struct Point
{
    int x[K],num;
    bool operator < (const Point &u) const
    {
        return x[idx]<u.x[idx];
    }
} P[N];

struct KD_Tree
{
    struct Node
    {
        int l[K],r[K],sz,max;
        Point x;
    } p[N<<2];

    void push_up(int i)
    {
        for(int j=0;j<k;j++)
        {
            if (~p[i<<1].sz) p[i].l[j]=min(p[i].l[j],p[i<<1].l[j]);
            if (~p[i<<1].sz) p[i].r[j]=max(p[i].r[j],p[i<<1].r[j]);
            if (~p[i<<1|1].sz) p[i].l[j]=min(p[i].l[j],p[i<<1|1].l[j]);
            if (~p[i<<1|1].sz) p[i].r[j]=max(p[i].r[j],p[i<<1|1].r[j]);
        }
        if (~p[i<<1].sz) p[i].max=max(p[i].max,p[i<<1].max);
        if (~p[i<<1|1].sz) p[i].max=max(p[i].max,p[i<<1|1].max);
    }

    void build(int i,int l,int r,int dep)
    {
        if (l>r) return;
        int mid=(l+r)>>1;
        idx=dep%k; p[i].sz=r-l;
        p[i<<1].sz=p[i<<1|1].sz=-1;
        nth_element(P+l,P+mid,P+r+1);
        build(i<<1,l,mid-1,dep+1);
        build(i<<1|1,mid+1,r,dep+1);
        for(int j=0;j<k;j++)
            p[i].l[j]=p[i].r[j]=P[mid].x[j];
        p[i].x=P[mid]; p[i].max=p[i].x.num; push_up(i);
    }

    bool in(Point x,Point l,Point r)
    {
        for(int j=0;j<k;j++)
            if (x.x[j]<l.x[j]||x.x[j]>r.x[j]) return 0;
        return 1;
    }

    bool intersection(int i,Point l,Point r)
    {
        for(int j=0;j<k;j++)
            if (p[i].r[j]<l.x[j]||p[i].l[j]>r.x[j]) return 0;
        return 1;
    }

    void getmin(int i,Point l,Point r,int &ans)
    {
        int lc=0,rc=0;
        if (in(p[i].x,l,r)) ans=max(ans,p[i].x.num);
        if (intersection(i<<1,l,r)) lc=p[i<<1].max;
        if (intersection(i<<1|1,l,r)) rc=p[i<<1|1].max;
        if (lc>rc)
        {
            if (lc>ans&&~p[i<<1].sz) getmin(i<<1,l,r,ans);
            if (rc>ans&&~p[i<<1|1].sz) getmin(i<<1|1,l,r,ans);
        }else
        {
            if (rc>ans&&~p[i<<1|1].sz) getmin(i<<1|1,l,r,ans);
            if (lc>ans&&~p[i<<1].sz) getmin(i<<1,l,r,ans);
        }
    }

} KDT;

int main()
{
    scanf("%d%d",&n,&q);
    for(int i=0;i<n;i++)
        scanf("%d",&P[i].num);
    memset(pos,-1,sizeof(pos));
    for(int i=0;i<n;i++)
    {
        P[i].x[1]=pos[P[i].num];
        pos[P[i].num]=i; P[i].x[0]=i;
    }
    memset(pos,INF,sizeof(pos));
    for(int i=n-1;i>=0;i--)
    {
        P[i].x[2]=pos[P[i].num];
        pos[P[i].num]=i;
    }
    int ans=0;
    KDT.build(1,0,n-1,0);
    while(q--)
    {
        int x,y,ll,rr;
        scanf("%d%d",&x,&y);
        ll=min((x+ans)%n,(y+ans)%n);
        rr=max((x+ans)%n,(y+ans)%n);
        Point l=Point{ll,-1,rr+1},r=Point{rr,ll-1,INF};
        KDT.getmin(1,l,r,ans=0); printf("%d\n",ans);
    }
    return 0;
}