51nod 1290 Counting Diff Pairs(莫队算法)

最新推荐文章于 2021-09-20 19:45:34 发布

原创最新推荐文章于 2021-09-20 19:45:34 发布 · 483 阅读

0 ·

CC 4.0 BY-SA版权

莫队算法专栏收录该内容

4 篇文章

订阅专栏

本文介绍了一种使用树状数组解决区间查询问题的方法。针对特定数据范围的问题，通过离散化处理，解决了大规模数据输入下的区间查询难题。文中详细解释了如何构建树状数组并进行区间更新和查询的过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

弱鸡表示看完题后，除了暴力计算移动L和R带来的影响，并没想到什么好法子。遂找大佬题解：http://blog.youkuaiyun.com/zsgg_acm/article/details/50262735
是通过树状数组处理的。
因为数据范围是1e9，所以要先离散化，不然没法处理。。离散化的时候载坑里了，调了老久。
举个例子：
假设现在的序列是:1,2,3，k=3，树状数组c全为0，要查询整个区间[1,3]内有多少对数字的差的绝对值<=k，此时L=1,R=0,L=l，不需要移动，R < r，右移，移到位置1，查询此时[1-3,1+3]区间和，res = 0，这时候加上1的贡献，c[1] = 1，然后R++，计算[2-3,2+3]区间和，res=1，这里有一对，然后再加上2的贡献，c[2]=1，然后R++，计算[3-3,3+3]的区间和，res=2，这里有两对，再加上3的贡献，c[3]=1，R==3，结束。这个询问共3对符合条件的数字。这组序列是连续，在题目中的数据，离散化之后也都是连续的了。还有1-3这些负数，离散化之后也都是正的了。
感觉我的叙述还是比较烂的，还是代码比较直观。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int MAXN = 5e5+10;
pair<int,int> rec[MAXN];
vector<int> vec;
int num[MAXN],cur[MAXN];
int Belong[MAXN];
int block;
LL res[MAXN];
int n,k,q;

struct Query
{
    int l,r,id;
} Q[MAXN];

bool cmp(const Query& a, const Query& b)
{
    if(Belong[a.l] == Belong[b.l])
        return a.r < b.r;
    return Belong[a.l] < Belong[b.l];
}

int c[MAXN];
void add(int i, int x)
{
    while(i <= n)
    {
        c[i] += x;
        i += (i&-i);
    }
}

//计算区间和
int query(int l, int r)
{
    int s = 0;
    while(r > 0)
    {
        s += c[r];
        r -= (r&-r);
    }
    --l;
    while(l > 0)
    {
        s -= c[l];
        l -= (l&-l);
    }
    return s;
}

void solve()
{
    int L = 1, R = 0;
    LL temp = 0;
    for(int i = 1; i <= q; ++i)
    {
        while(L < Q[i].l)
        {
            add(cur[L],-1);
            temp -= query(rec[L].first,rec[L].second);
            ++L;
        }
        while(L > Q[i].l)
        {
            --L;
            temp += query(rec[L].first,rec[L].second);
            add(cur[L],1);
        }
        while(R < Q[i].r)
        {
            ++R;
            temp += query(rec[R].first,rec[R].second);
            add(cur[R],1);
        }
        while(R > Q[i].r)
        {
            add(cur[R],-1);
            temp -= query(rec[R].first,rec[R].second);
            --R;
        }
        res[Q[i].id] = temp;
    }
}

//传来的flag主要用于判定是向左边的扩展，还是向右边的
//向右边的扩展x，如果在数组中不存在的话，就会返回比他大的那个数字的迭代器，那是不符合条件的
int tn;
int getid(int x, int flag)
{
    int id = lower_bound(vec.begin(),vec.end(),x)-vec.begin();
    if(id == tn) return tn;
    if(id == 0) return 1;
    if(flag)
        return id+1;
    else
    {
        if(vec[id] == x) return id+1;
        return id;
    }
}

int main()
{

    scanf("%d %d %d",&n,&k,&q);
    block = sqrt(n);
    for(int i = 1; i <= n; ++i)
    {
        scanf("%d",&num[i]);
        vec.push_back(num[i]);
        Belong[i] = (i-1)/block+1;
    }
    sort(vec.begin(),vec.end());
    vec.erase(unique(vec.begin(),vec.end()),vec.end());
    tn = vec.size();
    for(int i = 1; i <= n; ++i)
    {
        rec[i].first = getid(num[i]-k,1);
        rec[i].second = getid(num[i]+k,0);
        cur[i] = getid(num[i],1);
    }
    n = vec.size();
    for(int i = 1; i <= q; ++i)
    {
        scanf("%d %d",&Q[i].l,&Q[i].r);
        ++Q[i].l,++Q[i].r;
        Q[i].id = i;
    }
    sort(Q+1,Q+1+q,cmp);
    solve();
    for(int i = 1; i <= q; ++i)
        printf("%I64d\n",res[i]);
    return 0;
}