CSU 1515 Sequence 莫队算法

题目：http://acm.csu.edu.cn/OnlineJudge/problem.php?id=1515

题意：给定一个数组，每次询问一个区间，问区间中|a[i] - a[j]| == 1的组合有多少个。

思路：莫队算法。每当增加一个元素时就往答案中加上它左右临近元素的个数，减少一个元素就在答案中减去它左右临近元素的个数，思路很简单，但本题中数据范围较大，需要离散化，但是离散化之后|a[i] - a[j]| == 1的关系将受到影响，如何在离散化保证这个关系呢？有两种方法：第一种是用另外一个数组保存初始数组，然后增删元素计算答案时，我们用它对应的初始值减1去二分寻找左边的元素，若左边元素存在，就加上或减去左边元素的个数，计算右边元素的个数同理。第二种简单一些，也不用离散化，直接用map映射，初始值作为key，元素个数作为value，这样直接保证了|a[i] - a[j]| == 1的关系，速度稍慢了一点点

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <cmath>
#include <algorithm>
using namespace std;

typedef long long ll;
const int N = 10010;
struct node
{
    int l, r, id;
}g[N*10];
int a[N], b[N], c[N], num[N];
ll tmp, res[N*10];
int n, m, unit;
bool cmp(node a, node b)
{
    return a.l/unit != b.l/unit ? a.l/unit < b.l/unit : a.r < b.r;
}
void add(int i)
{
    num[a[i]]++;
    int j = lower_bound(b+1, b+1+n, c[i]-1) - b, k = lower_bound(b+1, b+1+n, c[i]+1) - b;
    if(c[i]-1 == b[j]) tmp += num[j];//左边临近元素存在
    if(c[i]+1 == b[k]) tmp += num[k];//右边临近元素存在
}
void del(int i)
{
    num[a[i]]--;
    int j = lower_bound(b+1, b+1+n, c[i]-1) - b, k = lower_bound(b+1, b+1+n, c[i]+1) - b;
    if(c[i]-1 == b[j]) tmp -= num[j];
    if(c[i]+1 == b[k]) tmp -= num[k];
}
void solve()
{
    unit = (int)sqrt(1.0 * n);
    memset(num, 0, sizeof num);
    sort(g+1, g+1+m, cmp);
    int l = 1, r = 0;
    tmp = 0;
    for(int i = 1; i <= m; i++)
    {
        while(r < g[i].r) add(++r);
        while(r > g[i].r) del(r--);
        while(l < g[i].l) del(l++);
        while(l > g[i].l) add(--l);
        res[g[i].id] = tmp;
    }
    for(int i = 1; i <= m; i++) printf("%lld\n", res[i]);
}
int main()
{
    while(~ scanf("%d%d", &n, &m))
    {
        for(int i = 1; i <= n; i++) scanf("%d", &a[i]), b[i] = c[i] = a[i];
        sort(b+1, b+1+n);
        for(int i = 1; i <= n; i++) a[i] = lower_bound(b+1, b+1+n, a[i]) - b;
        for(int i = 1; i <= m; i++) scanf("%d%d", &g[i].l, &g[i].r), g[i].id = i;
        solve();
    }
    return 0;
}