最近的事情更无语了,某鱼上现在有三个人在卖数据了。周赛数据永久停止更新。

不允许学生创建新讨论了,后面大家可以在这里讨论相关内容。会定期清理。

删了一些同学们自己举办的比赛的帖子。

我建议你们可以私聊参赛。讨论区太乱了,有些提问我看不到了已经。

更重要的是,还是先好好学算法吧各位同学,当你拿了提高组 200200 分,再考虑自己举办一些简单的比赛。

语法场的初心还是为了学生们巩固基础语法,高水平选手可以选择参加入门语法场和入门提高场 目前也没看见能打的 (参考新春马拉松赛成绩)

感觉不过瘾还可以打atcoder和codeforces

600 条评论

  • @ 2026-11-1 15:39:50

    题外话,避雷 35113511 的岚岱直火烤肉,又贵又不好吃。

    并且令我在外面排队了一个多少时才吃上。

    • @ 2026-11-1 15:43:36

      并且店员骗我说上菜很慢,说最多可能要等 11 小时上菜,让我一次多点一些,于是我一次点了 450450 元的菜品。

      其实上菜并不慢,我现在反应过来了,应该怕我第一次点少了后面不点了。

  • @ 2026-11-1 15:26:34

    赵弈泽,周浩铭,李瑞舟,袁世钊,你们还在吗

  • @ 2026-11-1 15:20:01

    @ 这里······真的还有西安校区的吗

  • @ 2026-11-1 13:14:16

    我真的乌鱼子

    • @ 2026-10-31 19:18:57

      窝是gay喵

    • @ 2026-10-31 14:55:33
      • @ 2026-10-29 20:59:17

        绷不住了

        • @ 2026-10-29 20:50:24

          选自《论语·信奥》

          • @ 2026-10-25 15:44:31

            what this ???

          • @ 2026-10-24 17:14:54

            ???

          • @ 2026-10-24 11:58:35

            • @ 2026-10-24 11:02:38

              • @ 2026-10-18 18:27:06

                • @ 2026-10-17 11:47:32

                  #include <bits/stdc++.h> using namespace std; int main(){ int s = 0; for(int i = 100; i >= 1; i --){ if(i % 3 == 1){ s += i; }

                  }
                  cout << s;
                  return 0;
                  

                  }

                  > - 1. ````language`

                  | Column | | | | | |

                  
                  | - | - | - | - | - | - |
                  | | | | | | |
                  | | | | | | |
                  | | | | | | |
                  | | | | | | |
                  • @ 2026-10-17 11:45:38

                    #include <bits/stdc++.h> using namespace std; int main(){ int s = 0; for(int i = 100; i >= 1; i --){ if(i % 3 == 1){ s += i; }

                    }
                    cout << s;
                    return 0;
                    

                    }

                    • @ 2026-10-17 11:42:27

                      • @ 2026-10-17 11:42:15

                        • @ 2026-10-17 11:40:59

                          • @ 2026-10-17 11:39:15

                            • @ 2026-10-17 11:38:58

                              • @ 2026-10-17 11:32:08

                                钟谨一676767676767767676767676767676767676767676767677677676767676767676767676767676776767676767676767677676776767676767667676767676767676767676767676767

                                • @ 2026-10-17 11:29:54

                                  6767676767676767676767676767

                                • @ 2026-10-17 11:29:30

                                  你好

                                • @ 2026-10-11 9:42:52

                                  • @ 2026-10-10 13:11:23

                                    孩子们,我是来打卡

                                    • ??????

                                      • 窝来晒一波

                                        • #include<bits/stdc++.h>
                                          #define int long long
                                          using namespace std;int n,w,a[1005],dp[10005]; signed main(){cin>>n>>w;for(int i=1;i<=n;i++){cin>>a[i];}dp[0]=1;for(int i=1;i<=n;i++){for(int j=a[i];j<=w;j++){dp[j]+=dp[j-a[i]];}}cout<<dp[w];}
                                          

                                          细节压行

                                          • 有没有玩火影的几级

                                          • ≽^•⩊•^≼ 喵~≽^•⩊•^≼ 喵~≽^•⩊•^≼ 喵~≽^•⩊•^≼ 喵~≽^•⩊•^≼ 喵~

                                            • 跟我一起学猫叫一起≽^•⩊•^≼ 喵~≽^•⩊•^≼ 喵~≽^•⩊•^≼ 喵~≽^•⩊•^≼ 喵~≽^•⩊•^≼ 喵~

                                              • 我的洛谷头像(Doge) 别告诉刘泽釴 千万别

                                                • @ 2026-10-1 18:29:08

                                                  求植僵经典射击噩梦的插件搭配和经济分配,卡了一周了,僵尸快跑和单枪匹马都试了,核心输出用的火炬豌豆,没招了

                                                • @ 2026-9-27 20:55:03

                                                  本次作业坑点:

                                                  • 最近评论区怎么没有聊天的了 这一排景象让我感到非常(不)好 我非常(不)想让大家不要聊天 所以 社区环境真(不)好啊 建议大家(不)多发代码 (不要)少聊天

                                                  • @ 2026-9-13 11:19:57

                                                    那个单 log 线段树树剖有人会写吗,帮我调一下这个题

                                                    #include<bits/stdc++.h>
                                                    #define int long long
                                                    using namespace std;
                                                    const int maxn=1e5+5;
                                                    int n,m,k,P[70];
                                                    vector<int>G[maxn];
                                                    int tot,dfn[maxn],rnk[maxn],L[maxn],R[maxn],top[maxn],siz[maxn],fa[maxn],dep[maxn],hson[maxn],cnt,lid[maxn],idl[maxn];
                                                    void dfs_build(int u,int F){
                                                    	siz[u]=1;
                                                    	for(int i=0;i<G[u].size();i++){
                                                    		int v=G[u][i];
                                                    		if(v==F)continue;
                                                    		fa[v]=u;
                                                    		dep[v]=dep[u]+1;
                                                    		dfs_build(v,u);
                                                    		siz[u]+=siz[v];
                                                    		if(siz[v]>siz[hson[u]])hson[u]=v;
                                                    	}
                                                    }
                                                    void dfs(int u,int F){
                                                    	dfn[u]=++tot;
                                                    	rnk[tot]=u;
                                                    	if(hson[u]){
                                                    		top[hson[u]]=top[u];
                                                    		dfs(hson[u],u);
                                                    	}
                                                    	for(int i=0;i<G[u].size();i++){
                                                    		int v=G[u][i];
                                                    		if(v==F||v==hson[u])continue;
                                                    		top[v]=v;
                                                    		dfs(v,u);
                                                    	}
                                                    }
                                                    int opt[maxn],a[maxn];
                                                    struct SGT{
                                                    	vector<int>val[65][2];
                                                    	vector<int>opt,ls,rs,mid;
                                                    }st;
                                                    vector<SGT>tr;
                                                    int trid;
                                                    void pushup(int rt){
                                                    	for(int i=0;i<k;i++){
                                                    		tr[trid].val[i][0][rt]=tr[trid].val[i][tr[trid].rs[rt]][tr[trid].val[i][0][tr[trid].ls[rt]]];
                                                    		tr[trid].val[i][1][rt]=tr[trid].val[i][tr[trid].rs[rt]][tr[trid].val[i][1][tr[trid].ls[rt]]];
                                                    	}
                                                    }
                                                    int newnode(){
                                                    	for(int i=0;i<64;i++){
                                                    		tr[trid].val[i][0].push_back(0);
                                                    		tr[trid].val[i][1].push_back(0);
                                                    	}
                                                    	tr[trid].ls.push_back(0);
                                                    	tr[trid].rs.push_back(0);
                                                    	tr[trid].mid.push_back(0);
                                                    	tr[trid].opt.push_back(0);
                                                    	return tr[trid].mid.size()-1;
                                                    }
                                                    bool calc(bool val,int op,bool xx){
                                                    	if(op==1)return (val&xx);
                                                    	if(op==2)return (val|xx);
                                                    	if(op==3)return (val^xx);
                                                    }
                                                    void buildcnt(int l,int r,int rt){
                                                    	if(l==r)return;
                                                    	int sum=0;
                                                    	for(int i=l;i<=r;i++)sum+=siz[rnk[i+dfn[lid[trid]]-1]]-siz[hson[rnk[i+dfn[lid[trid]]-1]]];
                                                    	sum/=2;
                                                    	int now=0;
                                                    	for(int i=l;i<=r;i++){
                                                    		if(now+siz[rnk[i+dfn[lid[trid]]-1]]-siz[hson[rnk[i+dfn[lid[trid]]-1]]]>=sum){
                                                    			tr[trid].mid[rt]=i;
                                                    			break;
                                                    		}
                                                    		now+=siz[rnk[i+dfn[lid[trid]]-1]]-siz[hson[rnk[i+dfn[lid[trid]]-1]]];
                                                    	}
                                                    	if(tr[trid].mid[rt]==r)tr[trid].mid[rt]--;
                                                    	tr[trid].ls[rt]=newnode();
                                                    	buildcnt(l,tr[trid].mid[rt],tr[trid].ls[rt]);
                                                    	tr[trid].rs[rt]=newnode();
                                                    	buildcnt(tr[trid].mid[rt]+1,r,tr[trid].rs[rt]);
                                                    }
                                                    void build(int l,int r,int rt){
                                                    	if(l==r){
                                                    		tr[trid].opt[rt]=opt[rnk[l+dfn[lid[trid]]-1]];
                                                    		for(int i=0;i<k;i++){
                                                    			tr[trid].val[i][0][rt]=calc(0,tr[trid].opt[i],((a[rnk[l+dfn[lid[trid]]-1]]>>i)&1));
                                                    			tr[trid].val[i][1][rt]=calc(1,tr[trid].opt[i],((a[rnk[l+dfn[lid[trid]]-1]]>>i)&1));
                                                    		}
                                                    		return;
                                                    	}
                                                    	build(l,tr[trid].mid[rt],tr[trid].ls[rt]);
                                                    	build(tr[trid].mid[rt]+1,r,tr[trid].rs[rt]);
                                                    	pushup(rt);
                                                    }
                                                    void init(int l,int r){
                                                    	tr.push_back(st);
                                                    	newnode();
                                                    	buildcnt(1,r-l+1,1);
                                                    	build(1,r-l+1,1);
                                                    }
                                                    void update(int X,int opc,int vc,int l,int r,int rt){
                                                    	if(l==r){
                                                    		tr[trid].opt[rt]=opc;
                                                    		for(int i=0;i<k;i++){
                                                    			tr[trid].val[i][0][rt]=calc(0,tr[trid].opt[i],((vc>>i)&1));
                                                    			tr[trid].val[i][1][rt]=calc(1,tr[trid].opt[i],((vc>>i)&1));
                                                    		}
                                                    		return;
                                                    	}
                                                    	if(X<=tr[trid].mid[rt])update(X,opc,vc,l,tr[trid].mid[rt],tr[trid].ls[rt]);
                                                    	else update(X,opc,vc,tr[trid].mid[rt]+1,r,tr[trid].rs[rt]);
                                                    	pushup(rt);
                                                    }
                                                    struct Val{
                                                    	bool val[65][2];
                                                    	Val(){for(int i=0;i<65;i++)val[i][0]=val[i][1]=0;}
                                                    };
                                                    Val query(int L,int R,int l,int r,int rt){
                                                    	if(L<=l&&r<=R){
                                                    		Val res;
                                                    		for(int i=0;i<k;i++)res.val[i][0]=tr[trid].val[i][0][rt],res.val[i][1]=tr[trid].val[i][1][rt];
                                                    		return res;
                                                    	}
                                                    	if(L<=tr[trid].mid[rt]&&tr[trid].mid[rt]+1<=R){
                                                    		Val res;
                                                    		Val ls=query(L,R,l,tr[trid].mid[rt],tr[trid].ls[rt]);
                                                    		Val rs=query(L,R,tr[trid].mid[rt]+1,r,tr[trid].rs[rt]);
                                                    		for(int i=0;i<k;i++){
                                                    			res.val[i][0]=rs.val[i][ls.val[i][0]];
                                                    			res.val[i][1]=rs.val[i][ls.val[i][1]];
                                                    		}
                                                    		return res;
                                                    	}else if(L<=tr[trid].mid[rt])return query(L,R,l,tr[trid].mid[rt],tr[trid].ls[rt]);
                                                    	else return query(L,R,tr[trid].mid[rt]+1,r,tr[trid].rs[rt]);
                                                    }
                                                    Val getans(int u,int v){
                                                    	Val res;
                                                    	bool flag=0;
                                                    	while(top[u]!=top[v]){
                                                    		if(dep[top[u]]<dep[top[v]])swap(u,v);
                                                    		trid=idl[top[u]];
                                                    		Val now=query(dfn[top[u]],dfn[u],1,R[trid]-L[trid]+1,1);
                                                    		if(!flag){
                                                    			res=now;
                                                    			flag=1;
                                                    		}else for(int i=0;i<k;i++)res.val[i][0]=now.val[i][res.val[i][0]],res.val[i][1]=now.val[i][res.val[i][1]];
                                                    		u=top[u];
                                                    	}
                                                    	if(dep[u]<dep[v])swap(u,v);
                                                    	trid=idl[top[u]];
                                                    	Val now=query(dfn[top[u]],dfn[u],1,R[trid]-L[trid]+1,1);
                                                    	if(!flag){
                                                    		res=now;
                                                    		flag=1;
                                                    	}else for(int i=0;i<k;i++)res.val[i][0]=now.val[i][res.val[i][0]],res.val[i][1]=now.val[i][res.val[i][1]];
                                                    	return res;
                                                    }
                                                    signed main(){
                                                    	//freopen(".in","r",stdin);
                                                    	//freopen(".out","w",stdout);
                                                    	ios::sync_with_stdio(0);
                                                    	cin.tie(0);
                                                    	cout.tie(0);
                                                    	cin>>n>>m>>k;
                                                    	for(int i=1;i<=n;i++)cin>>opt[i]>>a[i];
                                                    	P[0]=1;
                                                    	for(int i=1;i<=63;i++)P[i]=P[i-1]*2;
                                                    	for(int i=1;i<n;i++){
                                                    		int u,v;
                                                    		cin>>u>>v;
                                                    		G[u].push_back(v);
                                                    		G[v].push_back(u);
                                                    	}
                                                    	dep[1]=1;
                                                    	fa[1]=1;
                                                    	dfs_build(1,0);
                                                    	top[1]=1;
                                                    	dfs(1,0);
                                                    	for(int i=1;i<=n;i++){
                                                    		L[i]=n+1;
                                                    		if(!idl[top[i]]){
                                                    			idl[top[i]]=++cnt;
                                                    			lid[cnt]=top[i];
                                                    		}
                                                    	}
                                                    	for(int i=1;i<=n;i++)L[idl[top[i]]]=min(L[idl[top[i]]],dfn[i]),R[idl[top[i]]]=max(R[idl[top[i]]],dfn[i]);
                                                    	tr.push_back(st);
                                                    	for(int i=1;i<=cnt;i++){
                                                    		trid=cnt;
                                                    		init(L[lid[i]],R[lid[i]]);
                                                    	}
                                                    	while(m--){
                                                    		int OP,x,y,z;
                                                    		cin>>OP>>x>>y>>z;
                                                    		if(OP==1){
                                                    			Val res=getans(x,y);
                                                    			int now=0,ans=0;
                                                    			for(int i=k-1;i>=0;i--){
                                                    				if(res.val[i][0])ans+=P[i];
                                                    				else{
                                                    					if(res.val[i][1]){
                                                    						if(now+P[i]<=z){
                                                    							now+=P[i];
                                                    							ans+=P[i];
                                                    						}
                                                    					}
                                                    				}
                                                    			}
                                                    			cout<<ans<<'\n';
                                                    		}else{
                                                    			trid=idl[top[x]];
                                                    			update(x,y,z,1,R[trid]-L[trid]+1,1);
                                                    		}
                                                    	}
                                                    	return 0;
                                                    }
                                                    
                                                    • @ 2026-9-14 21:35:38

                                                      说实话,我一年半没碰过树这个OI概念了

                                                    • @ 2026-9-16 22:53:26
                                                      #include<bits/stdc++.h>
                                                      #define ull unsigned long long
                                                      using namespace std;
                                                      const int maxn=1e5+5;
                                                      int n,m,k;
                                                      ull P[70],a[maxn],mp;
                                                      vector<int>G[maxn];
                                                      int tot,dfn[maxn],rnk[maxn],L[maxn],R[maxn],top[maxn],siz[maxn],fa[maxn],dep[maxn],hson[maxn],cnt,lid[maxn],idl[maxn];
                                                      void dfs_build(int u,int F){
                                                      	siz[u]=1;
                                                      	for(int i=0;i<G[u].size();i++){
                                                      		int v=G[u][i];
                                                      		if(v==F)continue;
                                                      		fa[v]=u;
                                                      		dep[v]=dep[u]+1;
                                                      		dfs_build(v,u);
                                                      		siz[u]+=siz[v];
                                                      		if(siz[v]>siz[hson[u]])hson[u]=v;
                                                      	}
                                                      }
                                                      void dfs(int u,int F){
                                                      	dfn[u]=++tot;
                                                      	rnk[tot]=u;
                                                      	if(hson[u]){
                                                      		top[hson[u]]=top[u];
                                                      		dfs(hson[u],u);
                                                      	}
                                                      	for(int i=0;i<G[u].size();i++){
                                                      		int v=G[u][i];
                                                      		if(v==F||v==hson[u])continue;
                                                      		top[v]=v;
                                                      		dfs(v,u);
                                                      	}
                                                      }
                                                      int opt[maxn];
                                                      struct SGT{
                                                      	vector<ull>val[2],nval[2];
                                                      	vector<int>ls,rs,mid;
                                                      }st;
                                                      vector<SGT>tr;
                                                      int trid;
                                                      void pushup(int rt){
                                                      	tr[trid].val[0][rt]=(tr[trid].val[0][tr[trid].ls[rt]]&tr[trid].val[1][tr[trid].rs[rt]])
                                                      						+(~tr[trid].val[0][tr[trid].ls[rt]]&tr[trid].val[0][tr[trid].rs[rt]]);
                                                      	tr[trid].val[1][rt]=(tr[trid].val[1][tr[trid].ls[rt]]&tr[trid].val[1][tr[trid].rs[rt]])
                                                      						+(~tr[trid].val[1][tr[trid].ls[rt]]&tr[trid].val[0][tr[trid].rs[rt]]);
                                                      	tr[trid].nval[0][rt]=(tr[trid].nval[0][tr[trid].rs[rt]]&tr[trid].nval[1][tr[trid].ls[rt]])
                                                      						+(~tr[trid].nval[0][tr[trid].rs[rt]]&tr[trid].nval[0][tr[trid].ls[rt]]);
                                                      	tr[trid].nval[1][rt]=(tr[trid].nval[1][tr[trid].rs[rt]]&tr[trid].nval[1][tr[trid].ls[rt]])
                                                      						+(~tr[trid].nval[1][tr[trid].rs[rt]]&tr[trid].nval[0][tr[trid].ls[rt]]);
                                                      //	for(int i=0;i<k;i++){
                                                      //		tr[trid].val[0][rt]+=tr[trid].val[(tr[trid].val[0][tr[trid].ls[rt]]>>i)&1][tr[trid].rs[rt]]&P[i];
                                                      //		tr[trid].val[1][rt]+=tr[trid].val[(tr[trid].val[1][tr[trid].ls[rt]]>>i)&1][tr[trid].rs[rt]]&P[i];
                                                      //		tr[trid].nval[0][rt]+=tr[trid].nval[(tr[trid].nval[0][tr[trid].rs[rt]]>>i)&1][tr[trid].ls[rt]]&P[i];
                                                      //		tr[trid].nval[1][rt]+=tr[trid].nval[(tr[trid].nval[1][tr[trid].rs[rt]]>>i)&1][tr[trid].ls[rt]]&P[i];
                                                      //	}
                                                      }
                                                      int newnode(){
                                                      	tr[trid].val[0].push_back(0);
                                                      	tr[trid].val[1].push_back(0);
                                                      	tr[trid].nval[0].push_back(0);
                                                      	tr[trid].nval[1].push_back(0);
                                                      	tr[trid].ls.push_back(0);
                                                      	tr[trid].rs.push_back(0);
                                                      	tr[trid].mid.push_back(0);
                                                      	int t=tr[trid].mid.size();
                                                      	return t-1;
                                                      }
                                                      ull calc(ull val,int op,ull xx){
                                                      	if(op==1)return (val&xx);
                                                      	if(op==2)return (val|xx);
                                                      	if(op==3)return (val^xx);
                                                      }
                                                      void buildcnt(int l,int r,int rt){
                                                      //	cout<<l<<' '<<r<<' '<<rt<<'\n';
                                                      	if(l==r)return;
                                                      	int sum=0;
                                                      	for(int i=l;i<=r;i++)sum+=siz[rnk[i+dfn[lid[trid]]-1]]-siz[hson[rnk[i+dfn[lid[trid]]-1]]];
                                                      	sum/=2;
                                                      	int now=0;
                                                      	for(int i=l;i<=r;i++){
                                                      		if(now+siz[rnk[i+dfn[lid[trid]]-1]]-siz[hson[rnk[i+dfn[lid[trid]]-1]]]>=sum){
                                                      			tr[trid].mid[rt]=i;
                                                      			break;
                                                      		}
                                                      		now+=siz[rnk[i+dfn[lid[trid]]-1]]-siz[hson[rnk[i+dfn[lid[trid]]-1]]];
                                                      	}
                                                      	if(tr[trid].mid[rt]==r)tr[trid].mid[rt]--;
                                                      	int t=newnode();
                                                      	tr[trid].ls[rt]=t;
                                                      	buildcnt(l,tr[trid].mid[rt],tr[trid].ls[rt]);
                                                      	t=newnode();
                                                      	tr[trid].rs[rt]=t;
                                                      	buildcnt(tr[trid].mid[rt]+1,r,tr[trid].rs[rt]);
                                                      }
                                                      void build(int l,int r,int rt){
                                                      	if(l==r){
                                                      //		cout<<l<<' '<<a[rnk[l+dfn[lid[trid]]-1]]<<'\n';
                                                      		tr[trid].val[0][rt]=tr[trid].nval[0][rt]=calc(0,opt[rnk[l+dfn[lid[trid]]-1]],a[rnk[l+dfn[lid[trid]]-1]]);
                                                      		tr[trid].val[1][rt]=tr[trid].nval[1][rt]=calc(mp,opt[rnk[l+dfn[lid[trid]]-1]],a[rnk[l+dfn[lid[trid]]-1]]);
                                                      		return;
                                                      	}
                                                      	build(l,tr[trid].mid[rt],tr[trid].ls[rt]);
                                                      	build(tr[trid].mid[rt]+1,r,tr[trid].rs[rt]);
                                                      	pushup(rt);
                                                      }
                                                      void init(int l,int r){
                                                      //	cout<<l<<' '<<r<<'\n';
                                                      	tr.push_back(st);
                                                      	newnode();
                                                      	newnode();
                                                      	buildcnt(1,r-l+1,1);
                                                      	build(1,r-l+1,1);
                                                      //	cout<<1111<<'\n';
                                                      }
                                                      void update(int X,int opc,ull vc,int l,int r,int rt){
                                                      	if(l==r){
                                                      		tr[trid].val[0][rt]=tr[trid].nval[0][rt]=calc(0,opc,vc);
                                                      		tr[trid].val[1][rt]=tr[trid].nval[1][rt]=calc(mp,opc,vc);
                                                      		return;
                                                      	}
                                                      	if(X<=tr[trid].mid[rt])update(X,opc,vc,l,tr[trid].mid[rt],tr[trid].ls[rt]);
                                                      	else update(X,opc,vc,tr[trid].mid[rt]+1,r,tr[trid].rs[rt]);
                                                      	pushup(rt);
                                                      }
                                                      struct Val{
                                                      	ull val[2];
                                                      	void init(){val[0]=val[1]=0;}
                                                      };
                                                      Val query(int L,int R,int l,int r,int rt){
                                                      	if(L<=l&&r<=R){
                                                      		Val res;
                                                      		res.val[0]=tr[trid].val[0][rt],res.val[1]=tr[trid].val[1][rt];
                                                      		return res;
                                                      	}
                                                      	if(L<=tr[trid].mid[rt]&&tr[trid].mid[rt]+1<=R){
                                                      		Val res;
                                                      		Val ls=query(L,R,l,tr[trid].mid[rt],tr[trid].ls[rt]);
                                                      		Val rs=query(L,R,tr[trid].mid[rt]+1,r,tr[trid].rs[rt]);
                                                      		res.val[0]=(ls.val[0]&rs.val[1])
                                                      				 +(~ls.val[0]&rs.val[0]);
                                                      		res.val[1]=(ls.val[1]&rs.val[1])
                                                      				 +(~ls.val[1]&rs.val[0]);
                                                      		return res;
                                                      	}else if(L<=tr[trid].mid[rt])return query(L,R,l,tr[trid].mid[rt],tr[trid].ls[rt]);
                                                      	else return query(L,R,tr[trid].mid[rt]+1,r,tr[trid].rs[rt]);
                                                      }
                                                      Val queryn(int L,int R,int l,int r,int rt){
                                                      	if(L<=l&&r<=R){
                                                      		Val res;
                                                      		res.val[0]=tr[trid].nval[0][rt],res.val[1]=tr[trid].nval[1][rt];
                                                      		return res;
                                                      	}
                                                      	if(L<=tr[trid].mid[rt]&&tr[trid].mid[rt]+1<=R){
                                                      		Val res;
                                                      		Val rs=queryn(L,R,l,tr[trid].mid[rt],tr[trid].ls[rt]);
                                                      		Val ls=queryn(L,R,tr[trid].mid[rt]+1,r,tr[trid].rs[rt]);
                                                      		res.val[0]=(ls.val[0]&rs.val[1])
                                                      				 +(~ls.val[0]&rs.val[0]);
                                                      		res.val[1]=(ls.val[1]&rs.val[1])
                                                      				 +(~ls.val[1]&rs.val[0]);
                                                      		return res;
                                                      	}else if(L<=tr[trid].mid[rt])return queryn(L,R,l,tr[trid].mid[rt],tr[trid].ls[rt]);
                                                      	else return queryn(L,R,tr[trid].mid[rt]+1,r,tr[trid].rs[rt]);
                                                      }
                                                      vector<pair<int,int> >lu,lv;
                                                      vector<int>ru,rv;
                                                      Val getans(int u,int v){
                                                      	Val res;
                                                      	bool flag=0;
                                                      	int tu=u,tv=v;
                                                      	while(top[u]!=top[v]){
                                                      		if(dep[top[u]]<dep[top[v]])rv.push_back(v),lv.push_back({dfn[top[v]],dfn[v]}),v=fa[top[v]];
                                                      		else ru.push_back(u),lu.push_back({dfn[top[u]],dfn[u]}),u=fa[top[u]];
                                                      	}
                                                      	if(dep[u]>dep[v])ru.push_back(u),lu.push_back({dfn[v],dfn[u]});
                                                      	else rv.push_back(v),lv.push_back({dfn[u],dfn[v]});
                                                      	u=tu,v=tv;
                                                      	for(int i=0;i<lu.size();i++){
                                                      		trid=idl[top[ru[i]]];
                                                      //		cout<<trid<<' '<<lu[i].first-L[trid]+1<<' '<<lu[i].second-L[trid]+1<<'\n';
                                                      		Val now=queryn(lu[i].first-L[trid]+1,lu[i].second-L[trid]+1,1,R[trid]-L[trid]+1,1);
                                                      		if(!flag){
                                                      			res=now;
                                                      			flag=1;
                                                      		}else{
                                                      			res.val[0]=(res.val[0]&now.val[1])
                                                      					 +(~res.val[0]&now.val[0]);
                                                      			res.val[1]=(res.val[1]&now.val[1])
                                                      					 +(~res.val[1]&now.val[0]);
                                                      		}
                                                      //		put(res);
                                                      	}
                                                      //	cout<<1111;
                                                      	for(int i=rv.size()-1;i>=0;i--){
                                                      		trid=idl[top[rv[i]]];
                                                      //		cout<<trid<<' '<<lv[i].first<<' '<<lv[i].second<<'\n';
                                                      		Val now=query(lv[i].first-L[trid]+1,lv[i].second-L[trid]+1,1,R[trid]-L[trid]+1,1);
                                                      		if(!flag){
                                                      			res=now;
                                                      			flag=1;
                                                      		}else{
                                                      			res.val[0]=(res.val[0]&now.val[1])
                                                      					 +(~res.val[0]&now.val[0]);
                                                      			res.val[1]=(res.val[1]&now.val[1])
                                                      					 +(~res.val[1]&now.val[0]);
                                                      		}
                                                      //		put(res);
                                                      	}
                                                      	ru.clear();
                                                      	lu.clear();
                                                      	rv.clear();
                                                      	lv.clear();
                                                      	return res;
                                                      }
                                                      signed main(){
                                                      //	freopen("data.txt","r",stdin);
                                                      //	freopen("std.txt","w",stdout);
                                                      	ios::sync_with_stdio(0);
                                                      	cin.tie(0);
                                                      	cout.tie(0);
                                                      	cin>>n>>m>>k;
                                                      	for(int i=1;i<=n;i++)cin>>opt[i]>>a[i];
                                                      	P[0]=1;
                                                      	for(int i=1;i<=63;i++)P[i]=P[i-1]*2;
                                                      	for(int i=0;i<k;i++)mp+=P[i];
                                                      	for(int i=1;i<n;i++){
                                                      		int u,v;
                                                      		cin>>u>>v;
                                                      		G[u].push_back(v);
                                                      		G[v].push_back(u);
                                                      	}
                                                      	dep[1]=1;
                                                      	fa[1]=1;
                                                      	dfs_build(1,0);
                                                      	top[1]=1;
                                                      	dfs(1,0);
                                                      	for(int i=1;i<=n;i++){
                                                      		L[i]=n+1;
                                                      		if(!idl[top[i]]){
                                                      			idl[top[i]]=++cnt;
                                                      			lid[cnt]=top[i];
                                                      		}
                                                      //		cout<<top[i]<<' ';
                                                      	}
                                                      //	cout<<'\n';
                                                      	for(int i=1;i<=n;i++)L[idl[top[i]]]=min(L[idl[top[i]]],dfn[i]),R[idl[top[i]]]=max(R[idl[top[i]]],dfn[i]);
                                                      	tr.push_back(st);
                                                      	for(int i=1;i<=cnt;i++){
                                                      		trid=i;
                                                      		init(L[i],R[i]);
                                                      //		for(int j=1;j<tr[trid].mid.size();j++){
                                                      //			cout<<j<<' '<<tr[trid].ls[j]<<' '<<tr[trid].rs[j]<<' '<<tr[trid].mid[j]<<'\n';
                                                      //			for(int K=k-1;K>=0;K--)cout<<tr[trid].val[K][0][j]<<' '<<tr[trid].val[K][1][j]<<'\n';
                                                      //			cout<<'\n';
                                                      //			for(int K=k-1;K>=0;K--)cout<<tr[trid].nval[K][0][j]<<' '<<tr[trid].nval[K][1][j]<<'\n';
                                                      //			cout<<'\n';
                                                      //		}
                                                      //		cout<<'\n';
                                                      	}
                                                      	while(m--){
                                                      		int OP,x,y;
                                                      		ull z;
                                                      		cin>>OP>>x>>y>>z;
                                                      		if(OP==1){
                                                      			Val res=getans(x,y);
                                                      //			put(res);
                                                      			ull now=0,ans=0;
                                                      			for(int i=k-1;i>=0;i--){
                                                      				if((res.val[0]>>i)&1)ans+=P[i];
                                                      				else{
                                                      					if((res.val[1]>>i)&1){
                                                      						if(now+P[i]<=z){
                                                      							now+=P[i];
                                                      							ans+=P[i];
                                                      						}
                                                      					}
                                                      				}
                                                      			}
                                                      			cout<<ans<<'\n';
                                                      		}else{
                                                      			trid=idl[top[x]];
                                                      			update(dfn[x]-L[trid]+1,y,z,1,R[trid]-L[trid]+1,1);
                                                      //			for(int i=1;i<=cnt;i++){
                                                      //				trid=i;
                                                      //				for(int j=1;j<tr[trid].mid.size();j++){
                                                      //					cout<<j<<' '<<tr[trid].ls[j]<<' '<<tr[trid].rs[j]<<' '<<tr[trid].mid[j]<<'\n';
                                                      //					for(int K=k-1;K>=0;K--)cout<<tr[trid].val[K][0][j]<<' '<<tr[trid].val[K][1][j]<<'\n';
                                                      //					cout<<'\n';
                                                      //					for(int K=k-1;K>=0;K--)cout<<tr[trid].nval[K][0][j]<<' '<<tr[trid].nval[K][1][j]<<'\n';
                                                      //					cout<<'\n';
                                                      //				}
                                                      //				cout<<'\n';
                                                      //			}
                                                      		}
                                                      	}
                                                      	return 0;
                                                      }
                                                      
                                                      
                                                    • @ 2026-9-16 22:53:35

                                                      @ 我过了

                                                    • @ 2026-9-18 20:32:02

                                                      @ 我能抄代码吗

                                                  • @ 2026-9-10 22:43:03

                                                    @zby_dd 你现在是我同桌了,你作何感想

                                                  • 1

                                                    • k

                                                      • f

                                                        • TooY0ung 没硬币了,已感动

                                                        • P3718虬跳(92WA)。

                                                          #include<bits/stdc++.h>
                                                          using namespace std;
                                                          int n,k,ans;
                                                          char a[100005];
                                                          bool check(int mid){
                                                          	int num=1,sum=0;
                                                          	char last=a[1];
                                                          	for(int i=2;i<=n;i++){
                                                          		if(a[i]!=last){
                                                          			last=a[i],num=1;
                                                          		}
                                                          		else{
                                                          			num++;
                                                          			if(num>mid){
                                                          				num=1;
                                                          				if(last=='F')	last='N';
                                                          				else	last='F';
                                                          				sum++;
                                                          			}
                                                          		}
                                                          	}
                                                          	if(sum<=k)	return 1;
                                                          	else	return 0;
                                                          }
                                                          int main(){
                                                          	cin>>n>>k;
                                                          	for(int i=1;i<=n;i++)	cin>>a[i];
                                                          	int l=1,r=n;
                                                          	while(l<=r){
                                                          		int mid=(l+r)/2;
                                                          		if(check(mid)){
                                                          			ans=mid;
                                                          			r=mid-1;
                                                          		}
                                                          		else	l=mid+1;
                                                          	}
                                                          	cout<<ans;
                                                          }