BZOJ 4059: [Cerc2012]Non-boring sequences 启发式合并

4059: [Cerc2012]Non-boring sequences

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 712  Solved: 257
[Submit][Status][Discuss]

Description

我们害怕把这道题题面搞得太无聊了，所以我们决定让这题超短。一个序列被称为是不无聊的，仅当它的每个连续子序列存在一个独一无二的数字，即每个子序列里至少存在一个数字只出现一次。给定一个整数序列，请你判断它是不是不无聊的。

Input

第一行一个正整数T，表示有T组数据。每组数据第一行一个正整数n，表示序列的长度，1 <= n <= 200000。接下来一行n个不超过10^9的非负整数，表示这个序列。

Output

对于每组数据输出一行，输出"non-boring"表示这个序列不无聊，输出"boring"表示这个序列无聊。

Sample Input

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

Sample Output

non-boring
boring
non-boring
boring

显然我们需要log左右的复杂度

先来思考（其实我是最后想的。。。）如何处理最低复杂度搞出一个数字在给定区间内知否独一无二

先预处理出每个数字前一个、后一个于它相等的位置

这样就是O(1) 的了

现在来思考

若果在一个区间内，有独一无二的数，那么跨过它的区间都可行

所以可以递归处理它两侧的区间

但是显然这样复杂度是可以被卡到O(n^2)的

那么如何优化呢

考虑对于一个区间的处理

从两侧向中间寻找，复杂度最差O(n)

但是可以把区间分开，最后复杂度为O(nlogn)

可以看作是启发式合并的逆过程————启发式分裂  笑哭

#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<complex>
#include<iostream>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<string>
#include<bitset>
#include<queue>
#include<set>
#include<map>
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=200100;

bool flag;

int clr,a[N],col[N],last[N];

int L[N],R[N];

void solve(int l,int r)
{
	if(flag||l>r)return ;
	register int i=l,j=r;
	while(i<=j)
	{
		if(L[i]<l&&(!R[i]||R[i]>r))
		{solve(l,i-1);solve(i+1,r);return ;}
		else i++;
		if(L[j]<l&&(!R[j]||R[j]>r))
		{solve(l,j-1);solve(j+1,r);return ;}
		else j--;
	}
	flag=1;return ;
}

map<int,int>mp;

int main()
{
	int Q=read();
	register int i,n;
	while(Q--)
	{
		n=read();
		mp.clear();
		memset(L+1,0,sizeof(int)*n);memset(R+1,0,sizeof(int)*n);
		for(i=1;i<=n;++i){a[i]=read();L[i]=mp[a[i]];R[L[i]]=i;mp[a[i]]=i;}
		flag=0;clr=0;solve(1,n);
		flag?puts("boring"):puts("non-boring");
	}
}
/*
4
5
1 2 3 4 5
5
1 1 1 1 1
5
1 2 3 2 1
5
1 1 2 1 1

non-boring
boring
non-boring
boring
*/