HDU-3333：Turing Tree（莫队算法+线段树或树状数组+map或离散化）

题目链接：点击打开链接

题目大意：

有一段连续的数，让你求某段区间内的数的和，注意相同的数只算一次。

解题思路：

看到这道题猛然想起之前树状数组专题做过类似的。就果断拿过来一交，成功RE，淦。。。

仔细一看数的范围变成了1e9 数组开不下了。。。

其实这道题的解题关键在于莫队算法，以前我都管这叫离线操作，才知道原来是莫队算法，在此膜拜大神。。。

就是先将所有的查询操作保存起来，然后按照右端点从小到大排序。我们查找哪段区间，就把那段区间内的相同的数只保留最后一个。前面跟它相同的数可以算化成0。

而莫队算法同时保证了我们对这段区间的操作不会对后面的查询造成影响。所以，这道题就解决了，注意输出的时候按照之前查询的顺序输出即可。

这道题有个问题，就是点的范围过大，数组裸存存不下。可以用离散化解决，但是同时也可以用map ，被map坑了好多次，终于会用了。

所以我这种懒人目前是树状数组加map，map用来保存当前查询区间这个数最后出现的位置，至于离散化+线段树看有没有时间写吧。实现细节看代码，

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
#include<stack>
#include<map>
using namespace std;
typedef long long ll;
ll bit[30005];
int v[30005];
map <int,int> ma; //map存位置
int n;
ll ans[100005];
struct node
{
int l,r;
int id;
bool operator<(const node a) //按右端点从小到大排序
{
return r<a.r;
}
}s[200005];
ll sum(int i) //注意返回 ll 和下面 s 用 ll
{
ll s=0;
while(i>0)
{
s=s+bit[i];
i=i&(i-1);
}
return s;
}
void add(int i,int x)
{
while(i<=n)
{
bit[i]=bit[i]+x;
i=(i&-i)+i;
}
}
void vs(int ri,int r) //更新当前区间每个数最后出现的位置
{
for(int j=ri;j<=r;j++)
{
if(j!=ma[v[j]])
{
add(ma[v[j]],-v[j]); //将之前位置赋为0
ma[v[j]]=j;
}
}
}
int main()
{
int QAQ,qu;
scanf("%d",&QAQ);
while(QAQ--)
{
ma.clear();
memset(bit,0,sizeof(bit));
memset(s,0,sizeof(s));
memset(ans,0,sizeof(ans));
memset(v,0,sizeof(v));
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",&v[i]);
add(i,v[i]);
if(!ma[v[i]]) //先保存每个数第一次出现的位置
ma[v[i]]=i;
}
scanf("%d",&qu);
for(int i=1;i<=qu;i++)
{
scanf("%d%d",&s[i].l,&s[i].r);
s[i].id=i;
}
sort(s+1,s+1+qu);
int ri=1;
for(int i=1;i<=qu;i++)
{
vs(ri,s[i].r); //更新位置
ri=s[i].r;
ans[s[i].id]=sum(s[i].r)-sum(s[i].l-1);
}
for(int i=1;i<=qu;i++)
printf("%lld\n",ans[i]);
}
}