BZOJ 1483: [HNOI2009]梦幻布丁 启发式合并 邻接表活用

1483: [HNOI2009]梦幻布丁

Time Limit: 10 Sec  Memory Limit: 64 MB
Submit: 3364  Solved: 1324
[Submit][Status][Discuss]

Description

N个布丁摆成一行,进行M次操作.每次将某个颜色的布丁全部变成另一种颜色的,然后再询问当前一共有多少段颜色.例如颜色分别为1,2,2,1的四个布丁一共有3段颜色.

Input

第一行给出N,M表示布丁的个数和好友的操作次数. 第二行N个数A1,A2...An表示第i个布丁的颜色从第三行起有M行,对于每个操作,若第一个数字是1表示要对颜色进行改变，其后的两个整数X,Y表示将所有颜色为X的变为Y，X可能等于Y. 若第一个数字为2表示要进行询问当前有多少段颜色，这时你应该输出一个整数. 0

Output

针对第二类操作即询问，依次输出当前有多少段颜色.

Sample Input

4 3
1 2 2 1
2
1 2 1
2

Sample Output

3
1

像这种东西，启发式合并复杂度肯定是O(nlogn)的

但令人头疼的是如何实现

采取邻接表式的存储，每次修改，改变颜色的对应关系，更新答案

#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<string>
#include<bitset>
#include<queue>
#include<map>
#include<set>
using namespace std;

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch<='9'&&ch>='0'){x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
	return x*f;
}
void print(int x)
{if(x<0)putchar('-'),x=-x;if(x>=10)print(x/10);putchar(x%10+'0');}

const int N=1001000;

int n,m,ans;

int c[N],s[N],head[N],ft[N],nt[N],st[N];

inline void solve(int a,int b)
{
	register int i;
	for(i=head[a];i;i=nt[i])
	{
		if(c[i+1]==b)ans--;
		if(c[i-1]==b)ans--;
	}
	for(i=head[a];i;i=nt[i])c[i]=b;
	nt[st[a]]=head[b];head[b]=head[a];s[b]+=s[a];head[a]=st[a]=s[a]=0;
}

int main()
{
	n=read();m=read();
	register int i,x,a,b;
	for(i=1;i<=n;++i)
	{
		c[i]=read();ft[c[i]]=c[i];
		if(c[i]^c[i-1])ans++;
		if(!head[c[i]])st[c[i]]=i;
		s[c[i]]++;nt[i]=head[c[i]];head[c[i]]=i;
	}
	while(m--)
	{
		x=read();
		if(x==2){print(ans);puts("");}
		else 
		{
			a=read();b=read();
			if(a==b)continue;
			if(s[ft[a]]>s[ft[b]])swap(ft[a],ft[b]);
			a=ft[a],b=ft[b];
			if(!s[a])continue;
			s[b]+=s[a];s[a]=0;
			solve(a,b);
		}
	}
}
/*
4 3
1 2 2 1
2
1 2 1
2

3
1
*/