【BZOJ】【1878】【SDOI2009】HH的项链

树状数组/前缀和



  Orz lct1999

  好神的做法。。。

  先看下暴力的做法:对于区间[l,r],我们依次扫过去,如果这个数是第一次出现,那么我们种类数+1。

  我们发现:区间中相同的几个数,只有最左边那个才对答案有贡献。

  那么我们O(n)预处理一个next数组,满足a[i]=a[next[i]],且i~next[i]这一段中没有与a[i]相等的数。。。。其实就是 i 右边第一个跟a[i]相等的值的下标啦。。

  再回头看下我们的询问:对答案有贡献的数的特点是:它在整个序列中第一次出现,或者它是区间外某个数的next。在区间中再次出现的数,next指向它的数也一定也在区间中。

  

  那么我们处理查询[l,r]时,我们可以将[1,l-1]的next[i]对答案的共享+1,也就是我们维护一个ans数组,对ans[next[i]]++

  答案就是ans[r]-ans[l-1](都是前缀和)

  对询问进行左端点排序,树状数组维护一下即可……

  (然而感觉蒟蒻并没有讲清楚……大家可以去看zyf神犇的blog:http://www.cnblogs.com/zyfzyf/p/3935617.html

 1 /**************************************************************
 2     Problem: 1878
 3     User: Tunix
 4     Language: C++
 5     Result: Accepted
 6     Time:920 ms
 7     Memory:5768 kb
 8 ****************************************************************/
 9
10 //BZOJ 1878
11 #include<cstdio>
12 #include<cstring>
13 #include<cstdlib>
14 #include<iostream>
15 #include<algorithm>
16 #define rep(i,n) for(int i=0;i<n;++i)
17 #define F(i,j,n) for(int i=j;i<=n;++i)
18 #define D(i,j,n) for(int i=j;i>=n;--i)
19 #define pb push_back
20 using namespace std;
21 typedef long long LL;
22 inline int getint(){
23     int r=1,v=0; char ch=getchar();
24     for(;!isdigit(ch);ch=getchar()) if (ch==‘-‘) r=-1;
25     for(; isdigit(ch);ch=getchar()) v=v*10-‘0‘+ch;
26     return r*v;
27 }
28 const int N=50010,M=200010;
29 /*******************template********************/
30 int n,m,num,a[N],c[N],now[N],fi[N],next[N],ans[M];
31 struct que{int l,r,num;}q[M];
32 bool operator < (const que &a,const que &b){return a.l<b.l;}
33
34 int b[N],d[N];
35 void add(int x){
36     d[x]++;
37     if (!x) return;
38     for(int i=x;i<=n;i+=i&(-i)) b[i]++;
39 }
40 int sum(int x){
41     int r=0;
42     for(int i=x;i;i-=i&(-i)) r+=b[i];
43     return r;
44 }
45 void init(){
46     n=getint();
47     F(i,1,n) c[i]=a[i]=getint();
48     sort(c+1,c+n+1);
49     num=unique(c+1,c+n+1)-c-1;
50     F(i,1,n){
51         a[i]=lower_bound(c+1,c+num+1,a[i])-c;
52         if (now[a[i]]){
53             next[now[a[i]]]=i;
54             now[a[i]]=i;
55         }else{
56             add(i);
57             now[a[i]]=i;
58         }
59     }
60     m=getint();
61     F(i,1,m) q[i].l=getint(),q[i].r=getint(),q[i].num=i;
62 }
63 void solve(){
64     sort(q+1,q+m+1);
65     int now=1;
66     F(i,1,m){
67         while(now<q[i].l){
68             add(next[now]);
69             now++;
70         }
71         ans[q[i].num]=sum(q[i].r)-sum(q[i].l-1);
72     }
73     F(i,1,m) printf("%d\n",ans[i]);
74 }
75 int main(){
76 #ifndef ONLINE_JUDGE
77     freopen("1878.in","r",stdin);
78     freopen("1878.out","w",stdout);
79 #endif
80     init();
81     solve();
82     return 0;
83 }

1878: [SDOI2009]HH的项链

Time Limit: 4 Sec  Memory Limit: 64 MB
Submit: 2079  Solved: 1032
[Submit][Status][Discuss]

Description

HH有一串由各种漂亮的贝壳组成的项链。HH相信不同的贝壳会带来好运,所以每次散步
完后,他都会随意取出一段贝壳,思考它们所表达的含义。HH不断地收集新的贝壳,因此,
他的项链变得越来越长。有一天,他突然提出了一个问题:某一段贝壳中,包含了多少种不同
的贝壳?这个问题很难回答。。。因为项链实在是太长了。于是,他只好求助睿智的你,来解
决这个问题。

Input

第一行:一个整数N,表示项链的长度。
第二行:N个整数,表示依次表示项链中贝壳的编号(编号为0到1000000之间的整数)。
第三行:一个整数M,表示HH询问的个数。
接下来M行:每行两个整数,L和R(1 ≤ L ≤ R ≤ N),表示询问的区间。

Output

M行,每行一个整数,依次表示询问对应的答案。

Sample Input

6
1 2 3 4 3 5
3
1 2
3 5
2 6

Sample Output

2
2
4

HINT

对于20%的数据,N ≤ 100,M ≤ 1000;
对于40%的数据,N ≤ 3000,M ≤ 200000;
对于100%的数据,N ≤ 50000,M ≤ 200000。

Source

Day2

[Submit][Status][Discuss]

时间: 2024-08-09 06:33:56

【BZOJ】【1878】【SDOI2009】HH的项链的相关文章

BZOJ 1878: [SDOI2009]HH的项链( BIT )

离线处理 , 记下询问的左右端点并排序 , 然后可以利用树状数组 , 保证查询区间时每种颜色只计算一次 ------------------------------------------------------------------------------------------------ #include<cstdio> #include<algorithm> #include<cstring> #include<iostream> #define

[BZOJ 1878] [SDOI2009] HH的项链

题目链接: BZOJ - 1878 题目分析 题目的询问是某个区间内的颜色种类数,所以我们希望这个区间内的每种颜色只被计数一次,那么我们就选取询问区间内的每种颜色第一次出现的元素计数,之后再出现已经在询问区间中出现过的颜色就不再计数.考虑一种离线算法,如果我们将所有询问按照询问区间的左端点排序,那么所有询问的左端点就是不递减的,一直向右推移.开始时预处理出每个元素后面第一个与它颜色相同的元素是哪一个,并将所有出现的颜色的第一个元素加入到树状数组中.那么开始时维护的区间就是从 1 开始的.每次处理

BZOJ 1878 [SDOI2009]HH的项链 (主席树 或 莫队算法)

题目链接  HH的项链 这道题可以直接上主席树的模板 #include <bits/stdc++.h> using namespace std; #define rep(i, a, b) for (int i(a); i <= (b); ++i) #define dec(i, a, b) for (int i(a); i >= (b); --i) typedef long long LL; const int N = 5e4 + 10; const int M = 3e6 + 10

洛谷 P1972 BZOJ 1878 [SDOI2009]HH的项链

题目描述 HH 有一串由各种漂亮的贝壳组成的项链.HH 相信不同的贝壳会带来好运,所以每次散步完后,他都会随意取出一段贝壳,思考它们所表达的含义.HH 不断地收集新的贝壳,因此,他的项链变得越来越长.有一天,他突然提出了一个问题:某一段贝壳中,包含了多少种不同的贝壳?这个问题很难回答……因为项链实在是太长了.于是,他只好求助睿智的你,来解决这个问题. 输入输出格式 输入格式: 第一行:一个整数N,表示项链的长度. 第二行:N 个整数,表示依次表示项链中贝壳的编号(编号为0 到1000000 之间

bzoj 1878 [SDOI2009]HH的项链(离线处理+BIT)

Description HH有一串由各种漂亮的贝壳组成的项链.HH相信不同的贝壳会带来好运,所以每次散步 完后,他都会随意取出一段贝壳,思考它们所表达的含义.HH不断地收集新的贝壳,因此, 他的项链变得越来越长.有一天,他突然提出了一个问题:某一段贝壳中,包含了多少种不同 的贝壳?这个问题很难回答...因为项链实在是太长了.于是,他只好求助睿智的你,来解 决这个问题. Input 第一行:一个整数N,表示项链的长度. 第二行:N个整数,表示依次表示项链中贝壳的编号(编号为0到1000000之间的

BZOJ 1878: [SDOI2009]HH的项链 | 莫队

题解: http://www.lydsy.com/JudgeOnline/problem.php?id=1878 题解: 莫队板子题 核心思想是对区间的询问离线之后按照合理的顺序来优化复杂度 一般的做法是先分块,以左端点所在块为第一关键字,右端点位置为第二关键字排序 用两个指针来跑,这样可以证明的是时间复杂度为O(n√n) #include<cstdio> #include<algorithm> #include<cstring> #include<cmath&g

BZOJ 1878 SDOI2009 HH的项链 树状数组/莫队算法

题目大意:给定一个序列.求一个区间内有多少个不同的数 正解是树状数组 将全部区间依照左端点排序 然后每次仅仅统计左端点開始的每种颜色的第一个数即可了 用树状数组维护 我写的是莫队算法 莫队明显能搞 m√m明显慢了点可是还是能接受的一个复杂度 一開始离散化数组开小了各种秒RE-- 跪了 #include<cmath> #include<cstdio> #include<cstring> #include<iostream> #include<algori

BZOJ 1878 [SDOI2009]HH的项链 离线+树状数组

题意: 给一个n个数的序列,m个询问,每次询问一个区间内不相同的数的个数. 方法: 离线+树状数组 解析: 看完题后的确有段时间没有头绪,想过线段树来搞,不过好像很麻烦,然后听他们说离线下来搞.再推了1节课差不多就明白了. 离线和在线差距的确很大. 如果离线的话,所有的区间是呈线性的.大体思路是什么呢?就是每个数,我们都可以预处理出他上一次出现是在什么位置.然后对于一个区间的询问[l,r],我们可以这么去想这个询问:l~r中的数的上一次出现的位置在l左边的数的个数. 这样就很好弄了,先把所有的区

bzoj 1878: [SDOI2009]HH的项链【树状数组】

对于一个lr,每个颜色贡献的是在(1,r)区间里出现的最右位置,所以记录一个b数组表示当前点这个颜色上一个出现的位置 然后把询问离线,按r升序排序 每次把右端点右移,把这个点在树状数组上+1,并且在当前这个点的b位置上-1(表示没用了),然后树状数组前缀和减一下即可 我写的莫队会T #include<iostream> #include<cstdio> #include<algorithm> using namespace std; const int N=100000

BZOJ:1878: [SDOI2009]HH的项链

题解:解法一:莫队 解法二:按区间左端点排序,让区间内最左边的贝壳对答案产生贡献,树状数组维护,转移对答案产生贡献的贝壳位置 #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> using namespace std; const int maxn=1000009; int n,m; int a[maxn]; int nex[maxn]; int ans[maxn