反思
A
为什么打表就我看不出规律！！！
定式思维太严重了T_T
B
纯智障分块题，不知道为什么 B = 100 B=100 B=100 比理论最优 B = 300 B=300 B=300 更优（快了 3 倍），看来分块还是要学习一些卡常技巧的
C
菜死了，不会
D
菜死了，不会
题解
A
神奇的式子，考虑打表
打表！！！
可以发现一下两个规律：
- 只有当 x + y x+y x+y 是 2 2 2 的次幂时 f ( x , y ) f(x,y) f(x,y) 才可能不为 0 0 0
- f ( x , y ) = f ( x d , y d ) f(x,y)=f(\frac{x}{d},\frac{y}{d}) f(x,y)=f(dx,dy)，其中 d = gcd ( x , y ) d=\gcd(x,y) d=gcd(x,y)
且若 x + y = 2 k , x , y x+y=2^k,x,y x+y=2k,x,y 都为奇数且 ( x , y ) = 1 (x,y)=1 (x,y)=1 时， f ( x , y ) = k f(x,y)=k f(x,y)=k
考虑证明：
考虑 x + y x+y x+y 必须为偶数因为一直循环下去 x + y x+y x+y 的值不变
f ( x , y ) = f ( x d , y d ) f(x,y)=f(\frac{x}{d},\frac{y}{d}) f(x,y)=f(dx,dy) 是易得的
我们只需要考虑 x , y x,y x,y 都为奇数的情况，因为 x , y x,y x,y 为偶数时 2 ∣ gcd ( x , y ) 2|\gcd(x,y) 2∣gcd(x,y)
令 x > y x>y x>y，则 f ( x , y ) = f ( 2 y , x − y ) + 1 f(x,y)=f(2y,x-y)+1 f(x,y)=f(2y,x−y)+1
因为 2 y , x − y 2y,x-y 2y,x−y 都为偶数，所以 f ( x , y ) = f ( y , x − y 2 ) + 1 f(x,y)=f(y,\frac{x-y}{2})+1 f(x,y)=f(y,2x−y)+1
这样 x ′ + y ′ x'+y' x′+y′ 的值就除了 2 2 2，且因为 gcd ( x , y ) = 1 \gcd(x,y)=1 gcd(x,y)=1，所以 gcd ( y , x − y 2 ) = 1 \gcd(y,\frac{x-y}{2})=1 gcd(y,2x−y)=1
所以 x + y x+y x+y 只有当是 2 2 2 的次幂时， x ′ = y ′ x'=y' x′=y′，且操作次数为 l o g 2 ( x + y ) log_2(x+y) log2(x+y)
我们发现这有值的点对个数是 O ( n l o g n ) O(nlogn) O(nlogn) 级别的
所以我们可以把所有有值的点对找出来，然后询问就相当于二维数点了
离线询问 + 扫描线 + 树状数组即可
时间复杂度 O ( n l o g 2 n ) O(nlog^2n) O(nlog2n)
cpp
#include <bits/stdc++.h>
#define pb push_back
#define lowbit(x) x&-x
using namespace std;
typedef long long LL;
const int N=300100,Q=1000100;
struct Node{ int p1,p2,val;};
struct Node2{ int l,r,id,coef;};
int n,p[N],b[N];
LL tr[N],ans[Q];
Node used[N*40];
vector<Node2> query[N];
inline int read(){
int FF=0,RR=1;
char ch=getchar();
for(;!isdigit(ch);ch=getchar()) if(ch=='-') RR=-1;
for(;isdigit(ch);ch=getchar()) FF=(FF<<1)+(FF<<3)+ch-48;
return FF*RR;
}
bool cmp(const Node &x,const Node &y){ return x.p1<y.p1;}
void add(int x,int v){ for(;x<=n;x+=lowbit(x)) tr[x]+=v;}
LL ask(int x){
if(x<=0) return 0;
LL res=0;
for(;x;x-=lowbit(x)) res+=tr[x];
return res;
}
int main(){
freopen("perm.in","r",stdin);
freopen("perm.out","w",stdout);
n=read();
for(int i=1;i<=n;i++) p[i]=read(),b[p[i]]=i;
int cnt=0;
for(int pw=4,mi=2;pw<=n<<1;pw<<=1,mi++)
for(int x=1;x<=pw;x+=2){
int y=pw-x;
for(int k=1;k*max(x,y)<=n;k++) used[++cnt]={b[x*k],b[y*k],mi};
}
int q=read();
for(int i=1;i<=q;i++){
int l=read(),r=read();
query[l-1].pb({l,r,i,-1}),query[r].pb({l,r,i,1});
}
sort(used+1,used+cnt+1,cmp);
for(int i=1,j=0;i<=n;i++){
while(j<cnt&&used[j+1].p1<=i){
j++;
assert(used[j].p2>=1&&used[j].p2<=n);
add(used[j].p2,used[j].val);
}
for(Node2 t:query[i]) ans[t.id]+=t.coef*(ask(t.r)-ask(t.l-1));
}
for(int i=1;i<=q;i++) printf("%lld\n",ans[i]/2);
fprintf(stderr,"%d ms\n",int(1e3*clock()/CLOCKS_PER_SEC));
return 0;
}B
不说了，思想比较简单，就是分块 + 块内用优先队列维护
时间复杂度 O ( n m l o g n ) O(n\sqrt mlogn) O(nm logn)， m m m 为修改操作个数
块长设为 100 100 100 实测最优
cpp
#pragma GCC optimize(3)
#include <bits/stdc++.h>
using namespace std;
const int N=100100,MAXB=1010,P=1e9+7;
typedef pair<int,int> pii;
int n,m,a[N],pref[N],pos[N];
int B,sum[MAXB],tot[MAXB],tag[MAXB],_l[MAXB],_r[MAXB];
priority_queue<pii,vector<pii>,greater<pii> > pq[MAXB];
inline int read(){
int FF=0,RR=1;
char ch=getchar();
for(;!isdigit(ch);ch=getchar()) if(ch=='-') RR=-1;
for(;isdigit(ch);ch=getchar()) FF=(FF<<1)+(FF<<3)+ch-48;
return FF*RR;
}
inline int calc(int x){
int cur=sqrt(x);
return (pref[cur-1]+1ll*(x-cur*cur+1)*cur)%P;
}
inline void inc(int &x,int y){ x+=y;if(x>=P) x-=P;}
void rebuild(int Block){
for(int i=_l[Block];i<=_r[Block];i++) a[i]+=tag[Block];
tag[Block]=tot[Block]=sum[Block]=0;
while(!pq[Block].empty()) pq[Block].pop();
for(int i=_l[Block];i<=_r[Block];i++){
int sq=sqrt(a[i]);
inc(tot[Block],calc(a[i])),inc(sum[Block],sq);
pq[Block].emplace(make_pair((sq+1)*(sq+1)-a[i],i));
}
assert(tot[Block]>=0);
}
void modify(int l,int r){
if(pos[l]==pos[r]){
for(int i=l;i<=r;i++) a[i]++;
rebuild(pos[l]);
return;
}
else{
int i=l,j=r;
while(pos[i]==pos[l]) a[i]++,i++;
while(pos[j]==pos[r]) a[j]++,j--;
rebuild(pos[l]),rebuild(pos[r]);
for(int k=pos[i];k<=pos[j];k++){
tag[k]++;
pii t=pq[k].top();
while(t.first<=tag[k]){
pq[k].pop();
inc(sum[k],1);
int v=sqrt(a[t.second]+tag[k]);
assert(v*v==a[t.second]+tag[k]);
pq[k].push(make_pair((v+1)*(v+1)-a[t.second],t.second));
t=pq[k].top();
}
inc(tot[k],sum[k]);
}
}
}
int query(int l,int r){
int ans=0;
if(pos[l]==pos[r]){
rebuild(pos[l]);
for(int i=l;i<=r;i++) inc(ans,calc(a[i]));
}
else{
rebuild(pos[l]),rebuild(pos[r]);
int i=l,j=r;
while(pos[i]==pos[l]) inc(ans,calc(a[i])),i++;
while(pos[j]==pos[r]) inc(ans,calc(a[j])),j--;
for(int k=pos[i];k<=pos[j];k++) inc(ans,tot[k]);
}
return ans;
}
int main(){
freopen("play.in","r",stdin);
freopen("play.out","w",stdout);
for(int i=1;i<=40000;i++) pref[i]=(pref[i-1]+((1ll*(i+1)*(i+1)-1ll*i*i)%P+P)*i)%P;
for(int i=1;i<=40000;i++) assert(pref[i]>=0);
n=read(),m=read();
for(int i=1;i<=n;i++) a[i]=read();
B=100;
for(int i=1;i<=n;i++) pos[i]=(i-1)/B+1;
for(int i=1;i<=pos[n];i++) _l[i]=_r[i-1]+1,_r[i]=i*B;
_r[pos[n]]=n;
for(int i=1;i<=pos[n];i++) rebuild(i);
for(int i=1;i<=m;i++){
int op=read(),l=read(),r=read();
if(op==1) modify(l,r);
else printf("%d\n",query(l,r));
}
fprintf(stderr,"%d ms\n",int(1e3*clock()/CLOCKS_PER_SEC));
return 0;
}C
感觉是到有点 nb 的题
不考虑翻转，如何求 l i s lis lis？
考虑枚举分界点 i i i，那么答案 = max { i 前面 0 的个数 + i 后面 1 的个数 } =\max\{i前面0的个数+i后面1的个数\} =max{i前面0的个数+i后面1的个数}
这等价于 s 1 + max i = 1 n s u m i s1+\max\limits_{i=1}^{n} sum_i s1+i=1maxnsumi，其中 s 1 s1 s1 为序列中 1 1 1 的个数， s u m i sum_i sumi 为把 0 0 0 的权值设为 1 1 1， 1 1 1 的权值设为 − 1 -1 −1 的前缀和
考虑翻转操作
我们可以把这个问题等价地看成选出一段前缀和与 m m m 段不相交子区间（不能与前缀相交）的和的最大值
这一步感觉很难想，也很难理解
具体我也不会证，只能自己画图感性理解
然后就是经典的反悔贪心操作了，找最大的区间，然后区间取反，用线段树维护即可
时间复杂度 O ( n l o g n ) O(nlogn) O(nlogn)
cpp
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N=200100;
int n,val[N],s[N];
inline int read(){
int FF=0,RR=1;
char ch=getchar();
for(;!isdigit(ch);ch=getchar()) if(ch=='-') RR=-1;
for(;isdigit(ch);ch=getchar()) FF=(FF<<1)+(FF<<3)+ch-48;
return FF*RR;
}
struct Node{
int l,r,sum;
int lmx,rmx,mx,Lp,Rp,LLp,RRp;
int lmn,rmn,mn,Lq,Rq,LLq,RRq;
bool tag;
}seg[N<<2];
Node operator +(const Node &lc,const Node rc){
Node ret;ret.l=lc.l,ret.r=rc.r,ret.tag=0;
ret.sum=lc.sum+rc.sum;
ret.lmx=lc.lmx,ret.LLp=lc.LLp;
if(lc.sum+rc.lmx>ret.lmx) ret.lmx=lc.sum+rc.lmx,ret.LLp=rc.LLp;
ret.rmx=rc.rmx,ret.RRp=rc.RRp;
if(rc.sum+lc.rmx>ret.rmx) ret.rmx=rc.sum+lc.rmx,ret.RRp=lc.RRp;
ret.mx=lc.rmx+rc.lmx,ret.Lp=lc.RRp,ret.Rp=rc.LLp;
if(lc.mx>ret.mx) ret.mx=lc.mx,ret.Lp=lc.Lp,ret.Rp=lc.Rp;
if(rc.mx>ret.mx) ret.mx=rc.mx,ret.Lp=rc.Lp,ret.Rp=rc.Rp;
ret.lmn=lc.lmn,ret.LLq=lc.LLq;
if(lc.sum+rc.lmn<ret.lmn) ret.lmn=lc.sum+rc.lmn,ret.LLq=rc.LLq;
ret.rmn=rc.rmn,ret.RRq=rc.RRq;
if(rc.sum+lc.rmn<ret.rmn) ret.rmn=rc.sum+lc.rmn,ret.RRq=lc.RRq;
ret.mn=lc.rmn+rc.lmn,ret.Lq=lc.RRq,ret.Rq=rc.LLq;
if(lc.mn<ret.mn) ret.mn=lc.mn,ret.Lq=lc.Lq,ret.Rq=lc.Rq;
if(rc.mn<ret.mn) ret.mn=rc.mn,ret.Lq=rc.Lq,ret.Rq=rc.Rq;
return ret;
}
void down(int x){
swap(seg[x].lmx,seg[x].lmn),swap(seg[x].rmx,seg[x].rmn),swap(seg[x].mx,seg[x].mn);
swap(seg[x].Lp,seg[x].Lq),swap(seg[x].Rp,seg[x].Rq),swap(seg[x].LLp,seg[x].LLq),swap(seg[x].RRp,seg[x].RRq);
seg[x].sum*=-1,seg[x].lmx*=-1,seg[x].rmx*=-1,seg[x].mx*=-1,seg[x].lmn*=-1,seg[x].rmn*=-1,seg[x].mn*=-1;
seg[x].tag^=1;
}
void pushdown(int x){
if(seg[x].tag) down(x<<1),down(x<<1^1);
seg[x].tag=0;
}
void build(int l,int r,int x){
if(l==r){ seg[x]={l,l,val[l],val[l],val[l],val[l],l,l,l,l,val[l],val[l],val[l],l,l,l,l,0};return;}
int mid=(l+r)>>1;
build(l,mid,x<<1),build(mid+1,r,x<<1^1);
seg[x]=seg[x<<1]+seg[x<<1^1];
}
void modify(int l,int r,int x,int L,int R){
if(L<=l&&r<=R){ down(x);return;}
pushdown(x);
int mid=(l+r)>>1;
if(mid>=L) modify(l,mid,x<<1,L,R);
if(mid<R) modify(mid+1,r,x<<1^1,L,R);
seg[x]=seg[x<<1]+seg[x<<1^1];
}
signed main(){
freopen("lis.in","r",stdin);
freopen("lis.out","w",stdout);
n=read();
int ans=0;
for(int i=1;i<=n;i++){
int a=read(),b=read();
if(a==0) a=1;
else a=-1,ans+=b;
val[i]=a*b,s[i]=s[i-1]+val[i];
}
int mx=0;s[0]=-1e18;
for(int i=1;i<=n;i++) if(s[i]>s[mx]) mx=i;
build(1,n,1);
if(s[mx]>0) ans+=s[mx],modify(1,n,1,1,mx);
printf("%lld\n",ans);
int m=read();
for(int i=1;i<=m;i++){
Node ret=seg[1];
if(ret.mx>0) ans+=ret.mx,modify(1,n,1,ret.Lp,ret.Rp);
printf("%lld\n",ans);
}
fprintf(stderr,"%d ms\n",int64_t(1e3*clock()/CLOCKS_PER_SEC));
return 0;
}D
考虑暴力是 f i , j f_{i,j} fi,j 表示当前在 i i i，前一个选 j j j 的最大长度，因为 p i ≠ k p_i\neq k pi=k 的限制很松，所以直接记录最大值和次大值就可以维护，时间复杂度 O ( n 3 ) O(n^3) O(n3)
于是我们可以猜测需要保留的转移状态不会太多，事实上是真的
我们令三元组 ( l e n t h , p r e , i ) (lenth,pre,i) (lenth,pre,i) 表示当前在 i i i，上一个在 p r e pre pre，长度为 l e n t h lenth lenth 的状态
我们考虑用这个东西转移
每次答案，我们需要把 a j < a i a_j<a_i aj<ai 的 ( l e n t h , p r e , j ) (lenth,pre,j) (lenth,pre,j) 取出，然后更新 i i i 的状态
结论1：对于 i i i 只需要保留 l e n t h lenth lenth 最长的两个且满足 j p ≠ j q j_p\neq j_q jp=jq 的状态
首先 j j j 相等的状态只需要保留一个，那么后面最多只会排除掉 1 1 1 个状态，所以只需要暴力 2 2 2 个状态
结论2：只需要取出 ( l e n t h , p r e , j ) (lenth,pre,j) (lenth,pre,j) 的前 5 5 5 大 l e n t h lenth lenth，且对于 p r e pre pre 相同的，我们只保留最大的 2 2 2 个
为什么，考虑如果前两个的 p r e pre pre 都和 i i i 一样，那么后两个必然有两个 p r e pre pre 不相同的，是可以更新出 2 2 2 个有效答案的
时间复杂度 O ( n l o g n ) O(nlogn) O(nlogn)（但常数有点大，我稍微卡了一下常）
cpp
#pragma GCC optimize(3)
#include <bits/stdc++.h>
#define pb push_back
#define lowbit(x) x&-x
using namespace std;
const int N=200100;
inline int read(){
int FF=0,RR=1;
char ch=getchar();
for(;!isdigit(ch);ch=getchar()) if(ch=='-') RR=-1;
for(;isdigit(ch);ch=getchar()) FF=(FF<<1)+(FF<<3)+ch-48;
return FF*RR;
}
struct Node{ int lenth,pre,x;//以x结尾的长度为lenth的序列，前一个为pre的一种转移
};
vector<Node> tr[N];
int n,a[N],p[N],cnt[N];
bool cmp(const Node &o1,const Node &o2){ return o1.lenth>o2.lenth;}
auto select(vector<Node> vec){
sort(vec.begin(),vec.end(),cmp);
vector<Node> ret;
for(auto t:vec){
int c=0;
for(auto q:ret) if(q.pre==t.pre) c++;
if(c==2) continue;
ret.pb(t);
if(ret.size()==5) break;
}
return ret;
}
const int B=20;
void add(int x,vector<Node> ad){
for(;x<=n;x+=lowbit(x)){
for(auto t:ad) tr[x].pb(t);
if(tr[x].size()>=B) tr[x]=select(tr[x]);
}
}
auto query(int x){
vector<Node> ret;
for(;x;x-=lowbit(x)) for(auto t:tr[x]) ret.pb(t);
return ret;
}
void work(){
n=read();
for(int i=1;i<=n;i++) a[i]=read();
for(int i=1;i<=n;i++) p[i]=read();
int ans=0;
for(int i=1;i<=n;i++){
auto ret=query(a[i]-1);ret.pb({0,-1,-1});//以i为开头
ret=select(ret);
vector<Node> cur;
for(auto t:ret)
if(p[i]!=t.pre)
if(!cur.size()||t.x!=cur.back().pre){
cur.pb({t.lenth+1,t.x,i});
if(cur.size()==2) break;
}
for(auto t:cur) ans=max(ans,t.lenth);
add(a[i],cur);
}
printf("%d\n",ans);
for(int i=1;i<=n;i++) tr[i].clear();
}
int main(){
freopen("cactus.in","r",stdin);
freopen("cactus.out","w",stdout);
int T=read();
while(T--) work();
fprintf(stderr,"%d ms\n",int(1e3*clock()/CLOCKS_PER_SEC));
return 0;
}