[cf1434E]A Convex Game

暴力求SG，结论：每一个序列的SG上限为$sqrt{2max a_{i}}+1$

证明：将SG的转移看作一张DAG，归纳每一个点的SG值不超过其开始的最长路，显然成立

那么本题中最长路即在$a_{i}$中最多能选多少次，假设选择的权值依次为$v_{1},v_{2},...,v_{m}$，则$v_{i+1}-v_{i}ge i$，累加即$v_{m}-v_{1}ge frac{m(m-1)}{2}$，放缩得$(m-1)^{2}<2v_{m}$，$m$也即SG的上限为$sqrt{2max a_{i}}+1$

考虑dp，令$f_{i,j}$表示最后两次分别选了$a_{i}$和$a_{j}$的SG值，转移为$f_{i,j}=mex({f_{k,i}|a_{k}-a_{i}>a_{i}-a_{j}})$，利用$k$的单调性，倒序枚举$j$，可以做到$o(n^{2})$，最终答案即为$mex({f_{i,0}|1le ile n})$

令$g_{i,j}=min_{f_{i,k}>j}k$，根据上面的结论，$g$的总数量为$o(nsqrt{n})$，考虑直接转移$g$

根据单调性，有$g_{i,j}ge g_{i,j-1}$，这也就保证了$f_{i,g_{i,j}}$后面的集合包含了$[1,j)$，同时$j$也需要出现，因此即要求$exists k,a_{g_{i,j}}>2a_{i}-a_{k}且f_{k,i}=j$，后者又等价于$g_{k,j-1}le i<g_{k,j}$，贪心求出满足后者的$k$中最大值即可

考虑先枚举$j$，维护线段树，每一次先查询$i$上的值并判断，再令区间$[g_{i,j-1},g_{i,j})$的值对$i$取max，时间复杂度为$o(nsqrt{n}log_{2}n)$，略微卡常

进一步优化，由于插入的区间单调递增，因此可以看作对未被修改的部分修改，维护两个并查集，分别表示：1.上一个未被覆盖的点；2.同一种类型的上一个点，时间复杂度为$o(nsqrt{n}alpha(n))$

#include<bits/stdc++.h>
using namespace std;
#define N 100005
#define L (k<<1)
#define R (L+1)
#define mid (l+r>>1)
int t,n,ans,a[N],f[2][N],fa[N],pre[N],v[N];
int find(int k){
    if (fa[k]==k)return k;
    return fa[k]=find(fa[k]);
}
int get_pre(int k){
    if (k==pre[k])return k;
    return pre[k]=get_pre(pre[k]);
}
void update(int l,int r,int x){
    r=get_pre(r);
    if (v[r])r--;
    if (l>r)return;
    while (1){
        int nex=get_pre(r-1);
        if (v[nex])nex--;
        if (nex<l){
            v[r]=x;
            return;
        }
        fa[r]=nex;
        r=nex;
    }
}
void merge(int l,int r){
    if ((r<=n)&&(pre[r+1]==r+1)&&(v[r+1]))pre[r+1]=r;
    r=get_pre(r);
    while (l<r){
        pre[r]=r-1;
        r=get_pre(r-1);
    }
    if ((l==r)&&(l>1)&&(v[get_pre(l-1)]))pre[r]=r-1;
}
int query(int k){
    return v[find(k)];
}
int main(){
    scanf("%d",&t);
    while (t--){
        scanf("%d",&n);
        for(int i=1;i<=n;i++)scanf("%d",&a[i]);
        int s=0,p=0,flag=0;
        for(int i=1;i<=n;i++)f[p][i]=1;
        while (!flag){
            flag=1;
            s++;
            p^=1;
            for(int i=1;i<=n;i++){
                fa[i]=pre[i]=i;
                v[i]=0;
            }
            for(int i=n;i;i--){
                int k=query(i);
                if(!k)f[p][i]=n+1;
                else f[p][i]=upper_bound(a+1,a+n+1,2*a[i]-a[k])-a;
                if (f[p^1][i]>=f[p][i])f[p][i]=f[p^1][i];
                else{
                    update(f[p^1][i],f[p][i]-1,i);
                    merge(f[p^1][i],f[p][i]-1);
                }
                if (f[p][i]<=n)flag=0;
            }
        }
        ans^=s;
    }
    if (ans)printf("YES");
    else printf("NO");
}