[loj2461]完美的队列
参考论文，这里一共写了论文中的3种做法，第一种做法为强制在线时的做法，第二种为时间复杂度略高的做法（前两种都无法通过），第三种为本题正解，并给出了一种理论复杂度更优的做法
1.做法1
情况1
$\forall 1\le i\le n,a_{i}=1$
此时相当于维护一个序列，要求支持区间覆盖&求值的种类数
考虑去将相邻且权值（操作编号）相同的缩为一个段，用set来维护这些段，具体来说，对于每一段维护一个起点以及权值，将其作为set中的一个二元组，按起点从小到大排序
（特别的，为了避免有空隙而无法被表示，初始假设所有元素都为0）
对于一个操作，也就是将起点在$[l,r]$中的元素删除，并加入$(l,now)$以及$(r+1,last)$即可（其中$now$指当前操作的权值，$last$指插入前起点不超过$r$且最大的二元组的权值
（若已经存在以$r+1$为起点的二元组，则不插入$(r+1,last)$）
暴力删除即可，显然由于每一次至多产生两个元素，因此总时间复杂度为$o(n\log n)$
另外，关于答案的维护，直接统计所有二元组中每一个非0权值各有几个，在修改时维护即可
情况2
$\forall 1\le i\le n,a_{i}=k$
延续之前的做法，考虑去维护$k$个set
具体来说，将所有队列中的元素按队尾对齐，然后对于纵向的每一列维护一个set，每一次本要删除的元素加入下一个set中即可（对于最后一个set直接删除）
在加入下一个set时，我们要将所有元素一起插入，即先将其作为一个整体的$[l,r]$插入下一个set中，再将其中具体的每一段插入，避免新建过多节点
时间复杂度上，即每次操作至多产生$2k$个元素，且每一个元素至多被后移$k$次，因此总复杂度为$o(k^{2}n\log n)$
这个做法可以优化，如果通过splay来手动实现set，将这个区间在splay中分离出来，并直接接入到下一个中即可，这样的删除就不是均摊，而是每一次操作严格操作$k$次，总复杂度为$o(kn\log n)$
情况3
$\forall 1\le i\le n,a_{i}\le k$
此时先将其作为$\forall 1\le i\le n,a_{i}=k$来做，并预处理ST表来支持区间最小值，当某一个区间内$a_{i}$的最大值都小于当前set的编号则将其权值改为0（统计的是非0权值）
这样我们需要对所有操作的区间挨个检验，那么之前使用splay来优化并没有意义，仍为$o(k^{2}n\log n)$
考虑对每一个二元组再加一个权值，表示其区间内$a_{i}$的最大值，并用splay维护子树内的最小值，当发现存在最小值<set的编号，则找到最小值来源并删除即可
此时，由于每一个区间在被删除时才会有贡献，总复杂度变为$o(kn\log n)$
情况4
$\sum_{i=1}^{n}a_{i}\le 10^{6}$
这一情况下，将$a_{i}$分为两部分：
1.对于$a_{i}\le K$，将这些位置提出来变为一个另一个问题去做
2.对于$a_{i}>K$，这些位置数不超过$\frac{10^{6}}{K}$，每一次操作暴力检验是否影响到并插入即可
复杂度为$o(Kn\log n+\frac{10^{6}n}{K})$，取$K=\sqrt{\frac{10^{6}}{\log n}}$，复杂度即为$o(n\sqrt{10^{6}\log n})$，常数略卡
（实际情况下，由于空间问题，只能取$K=30$）
代码
1 #include<bits/stdc++.h> 2 using namespace std; 3 #define N 100005 4 #define s(p) f[k].ch[p] 5 struct node{ 6 int fa,ch[2],st,ed,val,lim,mn; 7 }f[N*61]; 8 vector<int>v; 9 queue<int>q[N]; 10 int V,K,n,m,l,r,x,ans,a[N],Log[N],ST[N][21],rt[N],tot[N]; 11 void add(int k){ 12 if (++tot[k]==1)ans++; 13 } 14 void dec(int k){ 15 if (--tot[k]==0)ans--; 16 } 17 int get_max(int x,int y){ 18 int p=Log[y-x+1]; 19 return min(max(ST[x][p],ST[y-(1<<p)+1][p]),K); 20 } 21 bool pd(int k){ 22 return f[f[k].fa].ch[1]==k; 23 } 24 int New(int st,int ed,int val){ 25 int k=++V; 26 f[k].fa=s(0)=s(1)=0; 27 f[k].st=st,f[k].ed=ed,f[k].val=val; 28 if (!val)f[k].lim=f[k].mn=K+1; 29 else{ 30 f[k].lim=f[k].mn=get_max(st,ed); 31 add(val); 32 } 33 return k; 34 } 35 void up(int k){ 36 f[k].mn=min(min(f[s(0)].mn,f[s(1)].mn),f[k].lim); 37 } 38 void connect(int k,int p,int u){ 39 f[u].fa=k; 40 if (k){ 41 s(p)=u; 42 up(k); 43 } 44 } 45 void rotate(int k){ 46 int fa=f[k].fa,ga=f[fa].fa,p=pd(k); 47 connect(ga,pd(fa),k); 48 connect(fa,p,s(p^1)); 49 connect(k,(p^1),fa); 50 } 51 void splay(int k,int fa){ 52 while (f[k].fa!=fa){ 53 int i=f[k].fa; 54 if (f[i].fa!=fa){ 55 if (pd(k)==pd(i))rotate(i); 56 else rotate(k); 57 } 58 rotate(k); 59 } 60 } 61 int find1(int &k,int x){ 62 int i=k,pos=0; 63 while (i){ 64 if (f[i].st>x)i=f[i].ch[0]; 65 else{ 66 pos=i; 67 i=f[i].ch[1]; 68 } 69 } 70 if (i){ 71 splay(i,f[k].fa); 72 k=i; 73 } 74 return pos; 75 } 76 int find2(int &k,int x){ 77 int i=k,pos=0; 78 while (i){ 79 if (f[i].st<=x)i=f[i].ch[1]; 80 else{ 81 pos=i; 82 i=f[i].ch[0]; 83 } 84 } 85 if (i){ 86 splay(i,f[k].fa); 87 k=i; 88 } 89 return pos; 90 } 91 void add(int &k,int x){ 92 int p=find1(k,f[x].st); 93 if (!p){ 94 connect(x,1,k); 95 k=x; 96 } 97 else{ 98 splay(p,f[k].fa); 99 k=p; 100 if (s(1))connect(x,1,s(1)); 101 connect(k,1,x); 102 } 103 } 104 void del(int &k,int x){ 105 splay(x,0); 106 k=x; 107 dec(f[k].val); 108 f[k].val=0; 109 f[k].lim=K+1; 110 up(k); 111 } 112 int main(){ 113 f[0].val=f[0].mn=0x3f3f3f3f; 114 scanf("%d%d",&n,&m); 115 for(int i=2;i<=n;i++)Log[i]=Log[i>>1]+1; 116 for(int i=1;i<=n;i++)scanf("%d",&a[i]); 117 K=30; 118 for(int i=1;i<=n;i++) 119 if (a[i]>K)v.push_back(i); 120 for(int i=n;i;i--){ 121 ST[i][0]=a[i]; 122 for(int j=1;j<=20;j++)ST[i][j]=max(ST[i][j-1],ST[min(i+(1<<j-1),n+1)][j-1]); 123 } 124 for(int i=1;i<=K;i++)rt[i]=New(1,n,0); 125 for(int i=1;i<=m;i++){ 126 scanf("%d%d%d",&l,&r,&x); 127 int ll=lower_bound(v.begin(),v.end(),l)-v.begin(); 128 int rr=upper_bound(v.begin(),v.end(),r)-v.begin()-1; 129 for(int j=ll;j<=rr;j++){ 130 add(x); 131 q[j].push(x); 132 if (q[j].size()>a[v[j]]){ 133 dec(q[j].front()); 134 q[j].pop(); 135 } 136 } 137 rt[0]=New(l,r,x); 138 for(int j=1;j<=K;j++){ 139 int p1=find1(rt[j],l-1); 140 if ((p1)&&(l<=f[p1].ed)){ 141 if (get_max(l,f[p1].ed)<j)add(rt[j],New(l,f[p1].ed,0)); 142 else add(rt[j],New(l,f[p1].ed,f[p1].val)); 143 splay(p1,0); 144 f[p1].ed=l-1; 145 rt[j]=p1; 146 if (f[p1].val){ 147 f[p1].lim=get_max(f[p1].st,f[p1].ed); 148 up(p1); 149 if (f[p1].lim<j)del(rt[j],p1); 150 } 151 } 152 int p2=find1(rt[j],r); 153 if ((r<n)&&(r<f[p2].ed)){ 154 if (get_max(r+1,f[p2].ed)<j)add(rt[j],New(r+1,f[p2].ed,0)); 155 else add(rt[j],New(r+1,f[p2].ed,f[p2].val)); 156 splay(p2,0); 157 f[p2].ed=r; 158 rt[j]=p2; 159 if (f[p2].val){ 160 f[p2].lim=get_max(f[p2].st,f[p2].ed); 161 up(p2); 162 if (f[p2].lim<j)del(rt[j],p2); 163 } 164 } 165 p2=find2(rt[j],r); 166 if (!p1){ 167 if (!p2)swap(rt[0],rt[j]); 168 else{ 169 splay(p2,0); 170 rt[j]=p2; 171 int k=f[rt[j]].ch[0]; 172 connect(0,0,k); 173 connect(rt[j],0,rt[0]); 174 rt[0]=k; 175 } 176 } 177 else{ 178 splay(p1,0); 179 rt[j]=p1; 180 if (!p2){ 181 int k=f[rt[j]].ch[1]; 182 connect(0,0,k); 183 connect(rt[j],1,rt[0]); 184 rt[0]=k; 185 } 186 else{ 187 splay(p2,rt[j]); 188 int k=f[p2].ch[0]; 189 connect(0,0,k); 190 connect(p2,0,rt[0]); 191 rt[0]=k; 192 up(rt[j]); 193 } 194 } 195 while ((rt[0])&&(f[rt[0]].mn==j)){ 196 int k=rt[0]; 197 while (f[k].lim!=j){ 198 if (f[s(0)].mn==j)k=s(0); 199 else k=s(1); 200 } 201 del(rt[0],k); 202 } 203 } 204 printf("%d\n",ans); 205 } 206 }
2.做法2
基本思路
对于第$i$个操作，称其影响操作$j$当且仅当第$j$次操作结束后，第$i$次操作插入的数字还在队列中
其所影响的操作是一个以$i$为左端点的连续区间，以下记作$[i,end_{i}]$，而当我们（离线）求出这个区间，简单差分一下就可以$o(n)$求出最终答案，因此以下考虑如何求$end_{i}$
先考虑一个更简单的问题，如何判定$i$是否影响$j$（其中$i\le j$），有如下的暴力做法：
1.$\forall i+1\le k\le j$，对序列$a_{i}$的$[l_{k},r_{k}]$区间减1（从初始的$a$序列开始操作）
2.求出序列$a_{i}$的$[l_{i},r_{i}]$的区间最大值，若大于0即影响操作$j$（否则不影响）
区间减1以及区间最大值用线段树来维护，复杂度即为$o(n^{2}\log^{2}n)$，但无法通过
分块优化
考虑分块，设块大小为$K$，将过程分为以下两部分：
1.确定$end_{i}$在哪一个块中
这可以通过对每一个块首（记作$st$）出发向前遍历，遍历过程中维护线段树，因此遍历到$i$即可判定$i$是否影响$st$，对于$i$影响的$st$中最大的$st$所在块即为$end_{i}$所在块
（特别的，若不存在则$end_{i}$在$i$所在块）
由于每一个块首遍历都要$o(n\log n)$的复杂度，总复杂度即$o(\frac{n^{2}}{K}\log n)$
2.求出$end_{i}$具体的位置
先枚举块，然后将$end_{i}$在该块中的询问取出，并从大到小排序
仍然从块首向前遍历，当遍历到的位置的答案在这个块中，将右端点向右移动，直至未被影响或到达块尾，即可求出该$end_{i}$，然后再将右端点移回块首
每一个操作复杂度为$o(K\log n)$（块首遍历与之前相同，不考虑），总复杂度即$(Kn\log n)$
综上，复杂度为$o(\frac{n^{2}}{K}\log n+Kn\log n)$，取$K=\sqrt{n}$即可做到$o(n\sqrt{n}\log n)$的复杂度
代码
1 #include<bits/stdc++.h> 2 using namespace std; 3 #define N 100005 4 #define L (k<<1) 5 #define R (L+1) 6 #define mid (l+r>>1) 7 struct Operator{ 8 int l,r,x; 9 }op[N]; 10 vector<int>v[N],v_add[N],v_dec[N]; 11 int K,n,m,ans_tot,a[N],bl[N],st[N],ed[N],f[N<<2],tag[N<<2],ans[N],tot[N],true_ans[N]; 12 void add(int k){ 13 if (++tot[k]==1)ans_tot++; 14 } 15 void dec(int k){ 16 if (--tot[k]==0)ans_tot--; 17 } 18 void upd(int k,int x){ 19 tag[k]+=x,f[k]+=x; 20 } 21 void down(int k){ 22 if (tag[k]){ 23 upd(L,tag[k]); 24 upd(R,tag[k]); 25 tag[k]=0; 26 } 27 } 28 void build(int k,int l,int r){ 29 tag[k]=0; 30 if (l==r){ 31 f[k]=a[l]; 32 return; 33 } 34 build(L,l,mid); 35 build(R,mid+1,r); 36 f[k]=max(f[L],f[R]); 37 } 38 void update(int k,int l,int r,int x,int y,int z){ 39 if ((l>y)||(x>r))return; 40 if ((x<=l)&&(r<=y)){ 41 upd(k,z); 42 return; 43 } 44 down(k); 45 update(L,l,mid,x,y,z); 46 update(R,mid+1,r,x,y,z); 47 f[k]=max(f[L],f[R]); 48 } 49 int query(int k,int l,int r,int x,int y){ 50 if ((l>y)||(x>r))return f[0]; 51 if ((x<=l)&&(r<=y))return f[k]; 52 down(k); 53 return max(query(L,l,mid,x,y),query(R,mid+1,r,x,y)); 54 } 55 int main(){ 56 f[0]=-0x3f3f3f3f; 57 scanf("%d%d",&n,&m); 58 for(int i=1;i<=n;i++)scanf("%d",&a[i]); 59 for(int i=1;i<=m;i++)scanf("%d%d%d",&op[i].l,&op[i].r,&op[i].x); 60 K=(int)sqrt(m); 61 for(int i=1;i<=m;i++)bl[i]=(i-1)/K+1; 62 for(int i=1;i<=bl[m];i++){ 63 st[i]=(i-1)*K+1; 64 ed[i]=min(i*K,m); 65 } 66 for(int i=1;i<=bl[m];i++){ 67 build(1,1,n); 68 for(int j=ed[i];j;j--){ 69 if (query(1,1,n,op[j].l,op[j].r)>0)ans[j]=i; 70 if (j<=st[i])update(1,1,n,op[j].l,op[j].r,-1); 71 } 72 } 73 for(int i=1;i<=m;i++)v[ans[i]].push_back(i); 74 for(int i=1;i<=bl[m];i++){ 75 build(1,1,n); 76 for(int j=ed[i];v[i].size();j--){ 77 if (v[i].back()==j){ 78 for(ans[j]=max(st[i],j);ans[j]<ed[i];ans[j]++){ 79 update(1,1,n,op[ans[j]+1].l,op[ans[j]+1].r,-1); 80 if (query(1,1,n,op[j].l,op[j].r)<=0)break; 81 } 82 for(int k=max(st[i],j);(k<=ans[j])&&(k<ed[i]);k++)update(1,1,n,op[k+1].l,op[k+1].r,1); 83 v[i].pop_back(); 84 } 85 if (j<=st[i])update(1,1,n,op[j].l,op[j].r,-1); 86 } 87 } 88 for(int i=1;i<=m;i++){ 89 v_add[i].push_back(op[i].x); 90 v_dec[ans[i]].push_back(op[i].x); 91 } 92 for(int i=1;i<=m;i++){ 93 for(int j=0;j<v_add[i].size();j++)add(v_add[i][j]); 94 printf("%d\n",ans_tot); 95 for(int j=0;j<v_dec[i].size();j++)dec(v_dec[i][j]); 96 } 97 }
3.做法3
基本思路
如果可以证明$\forall 1\le i<m,end_{i}\le end_{i+1}$，根据单调性，可以在$o(n\log n)$的时间内求出$end_{i}$
但这件事情显然是错误的，不过若第$i$次操作和第$j$次操作的区间相同（$i<j$），则$end_{i}\le end_{j}$
由此，我们想到将一个操作的区间拆开，并对相同的区间用单调性来做
考虑分块，同样以$K$为大小进行分块，将每一个操作拆为若干个整块操作和至多两个非整块操作，那么对于操作$i$的$end_{i}$，也就是所有拆出的操作的$end$的最大值
由于一个操作至多影响一个块，根据两个块之间的独立性，将每一个块的操作分别处理
具体来说，这个块内的操作分为整块操作和非整块操作，以下分别来处理
整块操作
先来说一下关于复杂度的描述：
记$n_{1}$为块内整块操作数，$n_{2}$为非整块操作数，用$n_{1}$和$n_{2}$来描述块内操作复杂度，并根据$\sum n_{1}=o(\frac{n^{2}}{K})$和$\sum n_{2}=o(n)$来求出总时间复杂度
对于整块操作，也就是操作区间相同，即可以根据单调性来做，块内复杂度为$o((n_{1}+n_{2})\log n)$，总时间复杂度即$o(\frac{n^{2}}{K}\log n)$
考虑优化，对整块操作直接在线段树外打懒标记即可，这样块内复杂度即降为$o(n_{1}+n_{2}\log n)$，累加后也就是$o(\frac{n^{2}}{K}+n\log n)$，可以忽略$o(n\log n)$，即$o(\frac{n^{2}}{K})$
另外，我们以此法找到的是块内的$end_{i}$，如果算上块外，应该取块内下一个操作（如果不存在则可以忽略或设置为$m+1$）减1作为其$end_{i}$，下面非整块操作相同
非整块操作
我们将这些操作再继续拆分，拆分为$K$个操作，这些操作同样可以用单调性来做
但这里的判定与之前不同，我们要加上我们所忽略了的整块操作，通过前缀和+差分来求出区间内的整块操作数即可计算
对于一个队列显然就不需要线段树了，复杂度为$o(Kn_{2}+n)$（这个$n$是前缀和+差分的复杂度）
我们现在对于$i$操作所找到的非整块操作，实际上是在$end_{i}$之前（包括$end_{i}$自身）第一个非整块操作，通过预处理每一个第$i$个整块操作以及之前的前缀和，可以$o(1)$找到$end_{i}$
综上，块内复杂度为$o(Kn_{2}+n)$，总复杂度为$o(Kn+\frac{n^{2}}{K})$
综合整块操作，复杂度仍然是$o(Kn+\frac{n^{2}}{K})$，取$K=\sqrt{n}$可做到$o(n\sqrt{n})$的复杂度
（另外，由于空间问题，需要将每一次继续拆分的$K$个操作所记录到的$K$个vector来重复利用）
代码
1 #include<bits/stdc++.h> 2 using namespace std; 3 #define N 100005 4 #define L (k<<1) 5 #define R (L+1) 6 #define mid (l+r>>1) 7 struct Operator{ 8 int l,r,x; 9 }; 10 vector<Operator>op[N]; 11 vector<int>v_all,v[N],v_add[N],v_dec[N]; 12 int K,n,m,l,r,ans_tot,a[N],bl[N],st[N],ed[N],val[N],sum[N],f[N<<2],tag[N<<2],ans[N],tot[N]; 13 void add(int k){ 14 if (++tot[k]==1)ans_tot++; 15 } 16 void dec(int k){ 17 if (--tot[k]==0)ans_tot--; 18 } 19 void upd(int k,int x){ 20 tag[k]+=x,f[k]+=x; 21 } 22 void down(int k){ 23 if (tag[k]){ 24 upd(L,tag[k]); 25 upd(R,tag[k]); 26 tag[k]=0; 27 } 28 } 29 void build(int k,int l,int r){ 30 tag[k]=0; 31 if (l==r){ 32 f[k]=a[l]; 33 return; 34 } 35 build(L,l,mid); 36 build(R,mid+1,r); 37 f[k]=max(f[L],f[R]); 38 } 39 void update(int k,int l,int r,int x,int y,int z){ 40 if ((l>y)||(x>r))return; 41 if ((x<=l)&&(r<=y)){ 42 upd(k,z); 43 return; 44 } 45 down(k); 46 update(L,l,mid,x,y,z); 47 update(R,mid+1,r,x,y,z); 48 f[k]=max(f[L],f[R]); 49 } 50 int main(){ 51 f[0]=-0x3f3f3f3f; 52 scanf("%d%d",&n,&m); 53 for(int i=1;i<=n;i++)scanf("%d",&a[i]); 54 K=(int)sqrt(n); 55 for(int i=1;i<=n;i++)bl[i]=(i-1)/K+1; 56 for(int i=1;i<=bl[n];i++){ 57 st[i]=(i-1)*K+1; 58 ed[i]=min(i*K,n); 59 } 60 for(int i=1;i<=m;i++){ 61 scanf("%d%d%d",&l,&r,&val[i]); 62 if (bl[l]==bl[r])op[bl[l]].push_back(Operator{l,r,i}); 63 else{ 64 op[bl[l]].push_back(Operator{l,ed[bl[l]],i}); 65 op[bl[r]].push_back(Operator{st[bl[r]],r,i}); 66 for(int j=bl[l]+1;j<bl[r];j++)op[j].push_back(Operator{st[j],ed[j],i}); 67 } 68 } 69 for(int i=1;i<=bl[n];i++){ 70 build(1,st[i],ed[i]); 71 v_all.clear(); 72 memset(sum,0,sizeof(sum)); 73 for(int j=0;j<=ed[i]-st[i];j++)v[j].clear(); 74 for(int j=0,k=0;j<op[i].size();j++){ 75 if (j)update(1,st[i],ed[i],op[i][j].l,op[i][j].r,1); 76 if ((op[i][j].l==st[i])&&(op[i][j].r==ed[i])){ 77 v_all.push_back(op[i][j].x); 78 sum[op[i][j].x]++; 79 while ((k<op[i].size())&&(f[1]>0)){ 80 k++; 81 if (k<op[i].size())update(1,st[i],ed[i],op[i][k].l,op[i][k].r,-1); 82 } 83 if (k==op[i].size())ans[op[i][j].x]=m; 84 else ans[op[i][j].x]=max(ans[op[i][j].x],op[i][k].x-1); 85 } 86 else{ 87 for(int t=op[i][j].l;t<=op[i][j].r;t++)v[t-st[i]].push_back(op[i][j].x); 88 } 89 } 90 for(int j=1;j<m;j++)sum[j+1]+=sum[j]; 91 for(int j=0;j<=ed[i]-st[i];j++){ 92 int lim=a[j+st[i]]; 93 for(int k=0,t=0;k<v[j].size();k++){ 94 while ((t<v[j].size())&&(t-k+sum[v[j][t]]-sum[v[j][k]]<lim))t++; 95 if (t<v[j].size()){ 96 if (t-k+sum[v[j][t]]-sum[v[j][k]]==lim)ans[v[j][k]]=max(ans[v[j][k]],v[j][t]-1); 97 else ans[v[j][k]]=max(ans[v[j][k]],v_all[lim+sum[v[j][k]]-t+k]-1); 98 } 99 else{ 100 if (t-k+sum[m]-sum[v[j][k]]<=lim)ans[v[j][k]]=m; 101 else ans[v[j][k]]=max(ans[v[j][k]],v_all[lim+sum[v[j][k]]-t+k]-1); 102 } 103 } 104 } 105 } 106 for(int i=1;i<=m;i++){ 107 v_add[i].push_back(val[i]); 108 v_dec[ans[i]].push_back(val[i]); 109 } 110 for(int i=1;i<=m;i++){ 111 for(int j=0;j<v_add[i].size();j++)add(v_add[i][j]); 112 printf("%d\n",ans_tot); 113 for(int j=0;j<v_dec[i].size();j++)dec(v_dec[i][j]); 114 } 115 }
线段树分治
事实上，这道题还可以做到更好的理论时间复杂度
考虑将区间用线段树去划分（类似于线段树分治的写法），用类似地方法处理，具体来说如下：
1.对于之前的整块操作，不能前缀和+差分以及暴力记录来查找，需要另外建立一棵线段树，并再返回时撤销即可，这里修改总复杂度为$o(n\log^{2}n)$，询问单次$o(\log n)$（包括求和以及查找）
2.对于每一个节点，将子树内所有操作都放在自己上并求出所有恰好覆盖该块，注意到这等价于线段树区间修改的复杂度，因此操作总量是$o(n\log n)$的，每一次需要修改限制以及在上面线段树查找，也是$o(n\log^{2}n)$
综上，我们得到了一个理论复杂度$o(n\log^{2}n)$，但其实际运行时间远劣于上面的分块
代码
1 #include<bits/stdc++.h> 2 using namespace std; 3 #define N 100005 4 #define L (k<<1) 5 #define R (L+1) 6 #define mid (l+r>>1) 7 struct Operator{ 8 int l,r,x; 9 }; 10 vector<Operator>op[N<<2]; 11 vector<int>v_add[N],v_dec[N]; 12 int n,m,l,r,ans_tot,a[N],val[N],lim[N<<2],tag[N<<2],sum[N<<2],ans[N],tot[N]; 13 void add(int k){ 14 if (++tot[k]==1)ans_tot++; 15 } 16 void dec(int k){ 17 if (--tot[k]==0)ans_tot--; 18 } 19 void upd(int k,int x){ 20 tag[k]+=x,lim[k]+=x; 21 } 22 void down(int k){ 23 if (tag[k]){ 24 upd(L,tag[k]); 25 upd(R,tag[k]); 26 tag[k]=0; 27 } 28 } 29 void build(int k,int l,int r){ 30 tag[k]=0; 31 if (l==r){ 32 lim[k]=a[l]; 33 return; 34 } 35 build(L,l,mid); 36 build(R,mid+1,r); 37 lim[k]=max(lim[L],lim[R]); 38 } 39 void update_lim(int k,int l,int r,int x,int y,int z){ 40 if ((l>y)||(x>r))return; 41 if ((x<=l)&&(r<=y)){ 42 upd(k,z); 43 return; 44 } 45 down(k); 46 update_lim(L,l,mid,x,y,z); 47 update_lim(R,mid+1,r,x,y,z); 48 lim[k]=max(lim[L],lim[R]); 49 } 50 void update_cover(int k,int l,int r,int x,int y){ 51 sum[k]+=y; 52 if (l==r)return; 53 if (x<=mid)update_cover(L,l,mid,x,y); 54 else update_cover(R,mid+1,r,x,y); 55 } 56 int query(int k,int l,int r,int x,int y){ 57 if ((l>y)||(x>r))return 0; 58 if ((x<=l)&&(r<=y))return sum[k]; 59 return query(L,l,mid,x,y)+query(R,mid+1,r,x,y); 60 } 61 int find(int k,int l,int r,int x){ 62 if (l==r)return l; 63 if (x<=sum[L])return find(L,l,mid,x); 64 return find(R,mid+1,r,x-sum[L]); 65 } 66 void add(int k,int l,int r,int x,int y,int z){ 67 if ((l>y)||(x>r))return; 68 op[k].push_back(Operator{max(l,x),min(r,y),z}); 69 if ((x<=l)&&(r<=y))return; 70 add(L,l,mid,x,y,z); 71 add(R,mid+1,r,x,y,z); 72 } 73 void dfs(int k,int l,int r){ 74 build(1,l,r); 75 for(int i=0,j=0;i<op[k].size();i++){ 76 int t=op[k][i].x; 77 if (i)update_lim(1,l,r,op[k][i].l,op[k][i].r,1); 78 if ((op[k][i].l==l)&&(op[k][i].r==r)){ 79 while ((j<op[k].size())&&(lim[1]>query(1,1,m,t,op[k][j].x))){ 80 j++; 81 if (j<op[k].size())update_lim(1,l,r,op[k][j].l,op[k][j].r,-1); 82 } 83 if (j==op[k].size()){ 84 if (query(1,1,m,t,m)<lim[1])ans[t]=m; 85 else ans[t]=max(ans[t],find(1,1,m,lim[1]+query(1,1,m,1,t))-1); 86 } 87 else{ 88 update_lim(1,l,r,op[k][j].l,op[k][j].r,1); 89 if (query(1,1,m,t,op[k][j].x)<lim[1])ans[t]=max(ans[t],op[k][j].x-1); 90 else ans[t]=max(ans[t],find(1,1,m,lim[1]+query(1,1,m,1,t))-1); 91 update_lim(1,l,r,op[k][j].l,op[k][j].r,-1); 92 } 93 } 94 } 95 for(int i=0;i<op[k].size();i++) 96 if ((op[k][i].l==l)&&(op[k][i].r==r))update_cover(1,1,m,op[k][i].x,1); 97 if (l<r){ 98 dfs(L,l,mid); 99 dfs(R,mid+1,r); 100 } 101 for(int i=0;i<op[k].size();i++) 102 if ((op[k][i].l==l)&&(op[k][i].r==r))update_cover(1,1,m,op[k][i].x,-1); 103 } 104 int main(){ 105 scanf("%d%d",&n,&m); 106 for(int i=1;i<=n;i++)scanf("%d",&a[i]); 107 for(int i=1;i<=m;i++){ 108 scanf("%d%d%d",&l,&r,&val[i]); 109 add(1,1,n,l,r,i); 110 } 111 dfs(1,1,n); 112 for(int i=1;i<=m;i++){ 113 v_add[i].push_back(val[i]); 114 v_dec[ans[i]].push_back(val[i]); 115 } 116 for(int i=1;i<=m;i++){ 117 for(int j=0;j<v_add[i].size();j++)add(v_add[i][j]); 118 printf("%d\n",ans_tot); 119 for(int j=0;j<v_dec[i].size();j++)dec(v_dec[i][j]); 120 } 121 }
