分治

首先感谢lrj的透彻讲解。

开始的时候我们可以用map来求出一个数的上一次出现的位置和下一次出现的位置，然后能判断一个数在\(l\)到\(r\)中这个数是否只出现了一次。

既然任意连续子序列都至少有一个元素唯一，那么我们可以找到这个序列中一个唯一存在的数，我们姑且认为ta的下标是k，进而我们发现任何包含这个数的区间都不是无聊的区间。

所以我们可以接着判断\(l\)到\(k-1\)的序列与\(k+1\)到\(r\)的序列是否是无聊的序列，若都不是，那\(l\)到\(r\)这个序列也就不是无聊的序列。

其中边界是

if(l==r||l>r)return 1;

我们又会发现一个问题，如果我们从左往右遍历，很明显如果我们需要求的\(k\)在最右边，每次分治都是这样的话时间复杂度就直接爆炸为O(\(n^2\)),从右往左遍历也会遇到这种情况。那么我们可以考虑从两边向中间遍历，在最坏的情况下\(k\)会在中间,那么时间复杂度就是经典递推式\(T(n)=2T(\frac{n}{2})+O(n)=O(nlog^n)\)（不理解的话建议学一下主定理）,可以接受。

最后献上我丑陋的代码

#include<iostream>
#include<cstdio>
#include<map>
using namespace std;
int T,n;
const int N=200010;
int a[N],pre[N],nt[N];
map<int,int>mp;
int read()
{
	char ch;int x=0,f=1;
	while(!isdigit(ch=getchar()))
	{(ch=='-')&&(f=-f);}
	while(isdigit(ch))
	{x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    return x*f;
}
bool work(int l,int r)
{
	if(l==r||l>r)return 1;
	int linl=l,linr=r;
	while(linr>linl)
	{
		linr--;
		if(pre[linr]<l&&nt[linr]>r)
			if(work(l,linr-1)&&work(linr+1,r))return 1;
		linl++;
		if(pre[linl]<l&&nt[linl]>r)
			if(work(l,linl-1)&&work(linl+1,r))return 1;
	}
	return 0;
}
int main()
{
	cin>>T;
	while(T--)
	{
		mp.clear();
		cin>>n;
		for(int i=1;i<=n;++i)
		{
			a[i]=read();
			pre[i]=0;nt[i]=n+1;		
		}
		for(int i=1;i<=n;++i)
		{
			if(mp.find(a[i])!=mp.end())pre[i]=mp[a[i]],nt[mp[a[i]]]=i;
			mp[a[i]]=i;
		}
		if(work(1,n))printf("non-boring\n");
		else printf("boring\n");
	}
	return 0;
}