BZOJ-1878-HH的项链-SDOI2009_1878 hh的项链-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_21110267/article/details/44839501

这篇博客详细介绍了SDOI2009年题目BZOJ-1878（HH的项链）的解题思路，包括离线树状数组统计和莫队算法两种方法。离线树状数组统计通过排序和更新避免了同种颜色重复计算，时间复杂度为O(nlogn)；莫队算法则采用分块思想，以O(n√n)的时间复杂度解决了问题。文章还提供了完整的C++代码实现。

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

描述

有n个位置(n ≤ 50000), 每个位置有一个颜色(颜色数 ≤ 200000).

询问[L, R]区间的颜色种数.

分析

两种解法都做了一下

1. 离线树状数组统计
HZWER:
将所有询问按照左端点进行排序, 将所有颜色的第一个点x, 将a[x]++, 然后从左往右扫, 扫到一个点x, 将a[next[x]]++, 碰到一个询问l,r输出sum[r]-sum[l-1], 其中sum是a数组的前缀和, 求前缀和可以用树状数组.
之所以这样做关键就是避免同种颜色计算多次, 这也是用树状数组解决问题的关键. 在L前的一个位置x, 如果next[x]在L之前, 用树状数组统计query(R)-query(L-1)时被减掉没有计算进去, 但之后一定会在结束对[L, R]的统计之前遇到这个next[x]; 如果next[x]在[L, R]的区间中, 那么更新next[x]之后query(R)-query(L-1)比原来大1, 也就是这个颜色被统计进去了, 而因为next[x]>L, 所以不会再遇到这个next[x]; 如果next[x]>R, 那么不会影响结果.
好巧妙的方式
O(nlogn)

2. 莫队算法
分块的做法:
将询问分 √n 块, 每一块内按R从小到大排序, 不同块之间按L从小到大排序. 然后用两个指针{p, q}扫描, 统计[p, q]区间内每个颜色的出现次数, 同时根据当前的答案统计对[L, R]区间的颜色种数造成的影响, 直到p==L&&q==R, 当前的答案就是[L, R]区间的答案.
感性的理解是这样分块让指针p, q在统计某一询问移动的次数尽可能少. 至于为什么我觉得没必要证啦...
O(n√n)

#include 
#include 
#include 
#include 
using namespace std;

const int maxn = 50000 + 10;
const int maxm = 200000 + 10;

map IDcache;

int cnt, cur, blocks;
int L, R;
int ans[maxm];
int A[maxn], c[maxn];

struct Question {
	int L, R, id;
	
	bool operator < (const Question& rhs) const {
		if(L/blocks == rhs.L/blocks) return R < rhs.R;
		return L < rhs.L;
	}
} questions[maxm];

#define q questions[i]

int id(int x) {
	if(IDcache.count(x)) return IDcache[x];
	return IDcache[x] = ++cnt;
}

int main()
{
	int n, m;
	scanf("%d", &n);
	for(int i = 1; i <= n; i++) {
		int x;
		scanf("%d", &x);
		A[i] = id(x);
	}
	scanf("%d", &m);
	for(int i = 0; i < m; i++) scanf("%d %d", &q.L, &q.R), q.id = i;
	blocks = (int)(sqrt(n) + 0.5);
	
	sort(questions, questions + m);
	for(int i = 0; i < m; i++) {
		while(L > q.L) if(++c[A[--L]] == 1) ++cur;
		while(R < q.R) if(++c[A[++R]] == 1) ++cur;
		while(L < q.L) if(--c[A[L++]] == 0) --cur;
		while(R > q.R) if(--c[A[R--]] == 0) --cur;
		ans[q.id] = cur;
	}
	for(int i = 0; i < m; i++) printf("%d\n", ans[i]);
	
	return 0;
}
#include 
#include 
#include 
using namespace std;

const int maxn = 50000 + 10;
const int maxm = 200000 + 10;

map IDcache;
int ID_cnt;
int A[maxn];
int ans[maxm];
int first[maxn], next[maxn];

struct Question {
	int L, R, id;
	
	void init(int i) {
		id = i;
		scanf("%d %d", &L, &R);
	}
	
	bool operator < (const Question& rhs) const {
		if(L == rhs.L) return R < rhs.R;
		return L < rhs.L;
	}
} questions[maxm];

struct BIT {
	int n;
	int c[maxn];
	
	int lowbit(int x) { return x & (-x); }
	
	void modify(int x, int d) {
		for(; x <= n; x += lowbit(x)) c[x] += d;
	}
	
	int query(int x) {
		int ret = 0;
		for(; x > 0; x -= lowbit(x)) ret += c[x];
		return ret;
	}
} bit;

int id(int x) {
	if(IDcache.count(x)) return IDcache[x];
	return IDcache[x] = ++ID_cnt;
}

#define a A[i]
#define q questions[i]

int main()
{
	int n, m;
	scanf("%d", &n);
	bit.n = n;
	for(int i = 1; i <= n; i++) {
		int x;
		scanf("%d", &x);
		A[i] = id(x);
	}
	for(int i = n; i >= 1; i--) {
		next[i] = first[a]; first[a] = i;
	}
	for(int i = 1; i <= ID_cnt; i++) if(first[i]) bit.modify(first[i], 1);
	scanf("%d", &m);
	for(int i = 0; i < m; i++) q.init(i);
	sort(questions, questions + m);
	
	int cur = 1;
	for(int i = 0; i < m; i++) {
		for(; cur < q.L; cur++) 
			if(next[cur]) bit.modify(next[cur], 1);
		ans[q.id] = bit.query(q.R) - bit.query(q.L-1);
	}
	for(int i = 0; i < m; i++) printf("%d\n", ans[i]);
	
	return 0;
}