HDU 4638 Group (树状数组+离线处理+思维)*

题目大意：http://acm.hdu.edu.cn/showproblem.php?pid=4638

#include<bits/stdc++.h>
using namespace std;
#define debug puts("YES");
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define read(x,y) scanf("%d%d",&x,&y)
#define ll long long
#define lrt int l,int r,int rt
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
const int  maxn =1e5+5;
const int mod=1e9+7;
/*
题目大意：给定一个权值序列，
和m个查询，查询这个序列最少可以分成多少个连续块（连续块比如2143这样）

在接触数据结构相关的内容时难免会有一个思想，
时间戳的思想，就是把特定的问题拟定时间性，
前面时间的操作不影响后面或相反。
还有个思想就是贡献，当前产生的影响对未来哪些点产生贡献，
这种思想经常结合查询，就是说当前位置更新的是未来可能查询到的点。

结合这题来看，先把查询离线，左端点相同的放在一起，
这样就产生了无后效性，就是说后面的操作不影响前面的答案，因为前面已经计算好了。
下面再分析下这题的性质，扫描到i位置，如果检测到a[i]的附近已经在之前被计算过了，
那么根据这题的意思，贡献应该相消，相消的位置就是a[i]-1,a[i]+1出现的位置，
就是说对于出现在位置之后的查询点贡献减少。

这样这题的结构就清晰了，倒序扫描，更新位置映射数组并累加贡献值，
然后处理相邻数字。
然后处理左端点出现在当前位置的查询集合。
*/
int n,m,x,y;
int ans[maxn];
int a[maxn];///数据域
int mp[maxn];///映射域
vector<pair<int,int>> qy[maxn];///查询结构
///树状数组结构
int tree[maxn];
int lowbit(int x)
{
    return x&(-x);
}
void add(int x,int d)
{
    for(;x<maxn;tree[x]+=d,x+=lowbit(x));
}
int sum(int x)
{
    int ret=0;
    for(;x>0;ret+=tree[x],x-=lowbit(x));
    return ret;
}
int main()
{
    int t;scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        memset(tree,0,sizeof(tree));
        memset(mp,-1,sizeof(mp));
        for(int i=0;i<=n;i++) qy[i].clear();
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&x,&y);
            qy[x].push_back(make_pair(y,i));
        }
        for(int i=n;i>=1;i--)
        {
            add(i,1);mp[a[i]]=i;///记录贡献产生或消去时发生的位置
            int pl=mp[a[i]-1],pr=mp[a[i]+1];
            if(~pl) add(mp[a[i]-1],-1);
            if(~pr) add(mp[a[i]+1],-1);
            for(int j=0;j<qy[i].size();j++)
            {
                int r=qy[i][j].first;
                int k=qy[i][j].second;
                ans[k]=sum(r)-sum(i-1);
            }
        }
        for(int i=0;i<m;i++) printf("%d\n",ans[i]);
    }
    return 0;
}