分治

首先感谢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;
}