2024 提高组杂题

T1 [CF1763C] Another Array Problem

弱智题。容易发现无论怎么操作 $\sum a_{i}$ 不会超过 $max a_{i} \times n$ ，且在 $n \geq 4$ 时一定能够取到。所以我们只需考虑 $n = 2$ 或 $n = 3$ 的情况。

$n = 2$ 时，只需取 $max (a_{1} + a_{2}, 2 \times | a_{1} - a_{2} |)$ 即可。

$n = 3$ 时，数组最后的取值只可能有 $a_{1} + a_{2} + a_{3}, 3 \times a_{1}, 3 \times a_{3}, 3 \times | a_{1} - a_{2} |, 3 \times | a_{2} - a_{3} |$ 五种情况。取 $max$ 即可。

constexpr int MAXN=2e5+5;
int T,n;
long long a[MAXN];

int main(){
	T=read();
	while(T--){
		n=read();
		for(int i=1;i<=n;++i) a[i]=read();
		if(n==2) write(max(abs(a[2]-a[1])<<1,a[1]+a[2]));
		else if(n==3) write(max(a[1]+a[2]+a[3],max({a[1],a[3],abs(a[1]-a[2]),abs(a[2]-a[3])})*n));
		else write(*max_element(a+1,a+n+1)*n);
	}
	return fw,0;
}

T2 [CF1775E] The Human Equation

精妙构造题。题目所给的操作看似复杂，但观察到一个加一、一个减一这种操作很像差分，于是把 $a$ 数组当成差分数组，还原出原数组 $b$ 。则在 $a$ 数组上的每一次操作都可以转化为将 $b$ 数组的任意值加或减一个数。

显然最少操作次数为 $b$ 数组的极差。

constexpr int MAXN=2e5+5;
int T,n;
long long a[MAXN];

int main(){
	T=read();
	while(T--){
		n=read();
		for(int i=1;i<=n;++i) a[i]=a[i-1]+read();
		long long mx=0,mn=0;
		for(int i=1;i<=n;++i) mx=max(mx,a[i]),mn=min(mn,a[i]);
		write(mx-mn);
	}
	return fw,0;
}

T3 [CF1290C] Prefix Enlightenment

前置知识：种类并查集。代表例题：[NOI2001] 食物链。

首先需要理解 ”任意三个子集的交集为空集“ 是什么意思。翻译成人话就是：任意一点顶多出现在两个集合中。于是我们设 $L_{i}, R_{i}$ 分别为包含 $i$ 点的两个集合（若没有则为 $0$ ）。

题目要求求出对于所有 $m_{i}$ ，于是我们考虑一个个加入。对于每个点都有如下情况讨论：

$S_{i} = 0$ ，则 $L_{i}, R_{i}$ 能且仅能操作一个；
$S_{i} = 1$ ，则 $L_{i}, R_{i}$ 要么都操作，要么都不操作。

这种维护条件的连通性的题目，想到种类并查集。对于每个集合 $k$ ，设立两个点分别表示操作/不操作，记为 $p (k, 0 / 1)$ 。则对于如上条件，我们只需连边：

$S_{i} = 0$ ，则连边 $p (L_{i}, 0) \leftrightarrow p (R_{i}, 0)$ 和 $p (L_{i}, 1) \leftrightarrow p (R_{i}, 1)$ ；
$S_{i} = 1$ ，则连边 $p (L_{i}, 0) \leftrightarrow p (R_{i}, 1)$ 和 $p (L_{i}, 1) \leftrightarrow p (R_{i}, 0)$ 。

显然，每一条边都代表一种合法的方案。连完边之后，对于每一个连通块，要么选 ”操作“，要么选 ”不操作“，于是我们在合并的时候统计第一层和第二层的最小值即可。

需要注意：

注意不能按秩合并，那样会导致关系混乱；只能用路径压缩。
还要注意：要处理一个点仅被一个集合包含的情况。在上文我们已经说了，如果不存在就是 $0$ 。所以 $0$ 点需要用来处理这种情况。并查集的空间应该是 $O (2 n)$ 的。
对于这个 $0$ 点不能操作。所以对于 $0$ 点的两层情况需要特判，只能取不包含的那一部分。

#include<bits/stdc++.h>
using namespace std;

constexpr int MAXN=3e5+5;
int n,k,ans;
char s[MAXN];
int L[MAXN],R[MAXN];
int f[MAXN<<1],siz[MAXN<<1][2];
int find(int x){
	return f[x]==x?x:f[x]=find(f[x]);
}
void combine(int u,int v){
	int fu=find(u),fv=find(v);
	if(fu==fv) return;
	ans-=min(siz[fu][0],siz[fu][1])+min(siz[fv][0],siz[fv][1]);
	siz[fu][0]+=siz[fv][0];
	siz[fu][1]+=siz[fv][1];
	f[fv]=fu;
	ans+=min(siz[fu][0],siz[fu][1]);
}

int main(){
	ios::sync_with_stdio(0);
	cin.tie(nullptr),cout.tie(nullptr);
	cin>>n>>k>>(s+1);
	for(int i=1,c,x;i<=k;++i){
		cin>>c;
		for(int j=1;j<=c;++j){
			cin>>x;
			L[x]?R[x]=i:L[x]=i;
		}
	}
	for(int i=0;i<=k;++i) f[i]=i,siz[i][0]=1;
	for(int i=k+1;i<=(k<<1|1);++i) f[i]=i,siz[i][1]=1;
	for(int i=1,rt;i<=n;++i){
		if(s[i]=='1') combine(L[i],R[i]),combine(L[i]+k+1,R[i]+k+1);
		else combine(L[i]+k+1,R[i]),combine(L[i],R[i]+k+1);
		rt=find(0);
		if(siz[rt][0]<siz[rt][1]) cout<<(ans>>1)+siz[rt][1]-siz[rt][0]<<'\n';
		else cout<<(ans>>1)<<'\n';
	}
	return 0;
}

T4 [CF1458D] Flip and Reverse

想象力/人类智慧/脑电波的构造题。对原串记 $0$ 为 $- 1$ ， $1$ 为 $+ 1$ ，得到新的序列；对这个序列做前缀和，记前缀和序列为 $s$ ，并连一条 $s_{i} \to s_{i + 1}$ 的有向边，可以得到一张图，一个欧拉回路就对应一个字符串。

然后转化题目中的奇怪操作。

要求 $[l, r]$ 的 01 个数相等，则 $s_{l - 1} = s_{r}$ ；
翻转 + 反转，实际上等于将 $[l, r]$ 的这些边反向。

所以该操作就等价于选择一个环然后将环上所有边反向。

然后需要观察出一个性质：操作前后，原图包含的边集不变。因为操作的是一个环，在操作前 $x \to y$ 和 $y \to x$ 的数量是相同的，所以操作后也是相同的。

还需要观察出另外一个性质。。原图任意一条欧拉回路代表的字符串都可以由原串经过操作得到。具体可以看 @tzc_wk 的证明。

于是此题就变为：求字典序最小的欧拉序！

直接贪心即可。

#include<bits/stdc++.h>
using namespace std;

constexpr int MAXN=5e5+5,N=5e5;
int T,n,cnt[MAXN<<1][2];
string s;

int main(){
	ios::sync_with_stdio(0);
	cin.tie(nullptr),cout.tie(nullptr);
	cin>>T;
	while(T--){
		cin>>s;
		n=s.size();
		s=' '+s;
		for(int i=1,cur=0;i<=n;++i){
			++cnt[cur+N][s[i]-'0'];
			cur+=s[i]=='0'?-1:1;
		}
		for(int i=1,x=0;i<=n;++i)
			if(cnt[x+N][0]&&cnt[x-1+N][1])
				--cnt[x+N][0],--x,cout<<0;
			else if(cnt[x+N][1])
				--cnt[x+N][1],++x,cout<<1;
			else --cnt[x+N][0],--x,cout<<0;
		cout<<'\n';
	}
	return 0;
}

T5 [CF1389F] Bicolored Segments

线段树优化 DP，当然也可以用神秘的 multiset 做。

首先像我就想到二分答案 + 离散化上去了，不过想一想就知道会假。

不过离散化肯定是正确的，先把所有区间离散化。

正解设 $f_{i, j, 0 / 1}$ 表示考虑到前 $i$ 个区间、最后一个放入的区间的右端点是 $j$ 、最后放入的区间的颜色是 $0 / 1$ 。其中第一维可以滚掉，第二维离散化之后空间不成问题。考虑优化时间。

不妨设当前线段是黑色的，也就是 $1$ 。

如果不选当前线段，显然有： $f_{i, r_{i}, 1} = f_{i - 1, r_{i - 1}, 1}$ 。

如果选当前线段，设上一条被选择的白色线段的右端点是 $r_{j}$ ，则所有左右端点都在 $(r_{j}, r_{i}]$ 的黑色线段都可以选择。则： $f_{i, r_{i}, 1} = max {f_{j, r_{j}, 0} + w}$ ，其中 $w$ 为这些黑色线段数量。

这里想要优化就需要状态提前计算。事先将所有 $r_{j} < l_{i}$ 的 $f_{j, r_{j}, 0}$ 都加上一个 $1$ ，则方程变为 $f_{i, r_{i}, 1} = max {f_{j, r_{j}, 0}}$ 。用一棵支持区间加、单点修、区间最大值的线段树搞它。

constexpr int MAXN=2e5+5;
int n,mx,b[MAXN<<1],tot;
struct SEG{
	int l,r,t;
	bool operator<(const SEG&x)const{
		return r<x.r;
	}
}a[MAXN];
int max(int a,int b){
	return a>b?a:b;
}
struct{
	#define lp p<<1
	#define rp p<<1|1
	#define mid ((s+t)>>1)
	struct SegTree{
		int c,lazy;
	}st[MAXN<<3];
	void pushdown(int p){
		if(!st[p].lazy) return;
		st[lp].c+=st[p].lazy,st[lp].lazy+=st[p].lazy;
		st[rp].c+=st[p].lazy,st[rp].lazy+=st[p].lazy;
		st[p].lazy=0; 
	}
	void pushup(int p){
		st[p].c=max(st[lp].c,st[rp].c);
	}
	void mdf(int l,int r,int k,int s=0,int t=mx,int p=1){
		if(l<=s&&t<=r) return st[p].c+=k,st[p].lazy+=k,void();
		pushdown(p);
		if(l<=mid) mdf(l,r,k,s,mid,lp);
		if(mid<r) mdf(l,r,k,mid+1,t,rp);
		pushup(p);
	}
	void chg(int x,int k,int s=0,int t=mx,int p=1){
		if(s==t) return st[p].c=k,void();
		pushdown(p);
		if(x<=mid) chg(x,k,s,mid,lp);
		else chg(x,k,mid+1,t,rp);
		pushup(p);
	}
	int sum(int l,int r,int s=0,int t=mx,int p=1){
		if(l<=s&&t<=r) return st[p].c;
		pushdown(p);
		int res=0;
		if(l<=mid) res=max(res,sum(l,r,s,mid,lp));
		if(mid<r) res=max(res,sum(l,r,mid+1,t,rp));
		return res;
	}
}s[2];

int main(){
	n=read();
	for(int i=1;i<=n;++i){
		a[i]={read(),read(),read()-1};
		b[++tot]=a[i].l,b[++tot]=a[i].r;
	}
	sort(b+1,b+tot+1);
	tot=unique(b+1,b+tot+1)-b-1;
	for(int i=1;i<=n;++i){
		a[i].l=lower_bound(b+1,b+tot+1,a[i].l)-b;
		a[i].r=lower_bound(b+1,b+tot+1,a[i].r)-b;
		mx=max(mx,a[i].r);
	}
	sort(a+1,a+n+1);
	for(int i=1,p;i<=n;++i){
		p=a[i].t;
		s[p].mdf(0,a[i].l-1,1);
		s[!p].chg(a[i].r,max(s[p].sum(0,a[i].l-1),s[!p].sum(0,a[i].r)));
	}
	printf("%d\n",max(s[0].st[1].c,s[1].st[1].c));
	return 0;
}

T6 [CF1580D] Subsequence

笛卡尔树的构造。将原式化为：

(m - 1) \sum_{i = 1}^{m} a_{b_{i}} - 2 \sum_{i = 1}^{m} \sum_{j = i + 1}^{m} min {a_{b_{i}}, \dots, a_{b_{j}}} .

把所有的 $a_{i}$ 放到笛卡尔树上，利用笛卡尔树的一个美妙的性质：连续区间最大值就是 LCA，将原式化为：

(m - 1) \sum_{i = 1}^{m} a_{b_{i}} - 2 \sum_{i = 1}^{m} \sum_{j = i + 1}^{m} a_{LCA (i, j)} .

设 $f_{u, j}$ 表示节点 $u$ 选择 $j$ 个节点的最大价值，初始 $f_{u, 1} = (m - 1) a_{i}$ ，然后类似树形背包地转移：

f_{u, i + j} = max {f_{u, i} + f_{v, j} - 2 \times i \times j \times a_{u}} .

constexpr int MAXN=4005;
int n,m,a[MAXN];
int ls[MAXN],rs[MAXN],stk[MAXN],top;
int f[MAXN][MAXN],tmp[MAXN],siz[MAXN];
void insert(int k,int w){
	while(top&&w<a[stk[top]]) ls[k]=stk[top--];
	if(top) rs[stk[top]]=k;
	stk[++top]=k;
}
bool vis[MAXN];
void dfs(int u);
void work(int u,int v){
	dfs(v);
	for(int i=0;i<=siz[u];++i) tmp[i]=f[u][i],f[u][i]=0;
	for(int i=0;i<=siz[u];++i)
		for(int j=0;j<=siz[v];++j)
			f[u][i+j]=max(f[u][i+j],tmp[i]+f[v][j]-2*a[u]*i*j);
	siz[u]+=siz[v];
}
void dfs(int u){
	f[u][1]=(m-1)*a[u];
	siz[u]=1;
	if(ls[u]) work(u,ls[u]);
	if(rs[u]) work(u,rs[u]);
}

signed main(){
	n=read(),m=read();
	for(int i=1;i<=n;++i) insert(i,a[i]=read());
	for(int i=1;i<=n;++i) vis[ls[i]]=vis[rs[i]]=1;
	for(int i=1;i<=n;++i)
		if(!vis[i]){
			dfs(i);
			printf("%lld\n",f[i][m]);
			return 0;
		}
}

T7 [CF1720D2] Xor-Subsequence (hard version)

Trie 树优化 DP。发现如果 $a_{i} \oplus j < a_{j} \oplus i$ ，则 $a_{i} \oplus j$ 和 $a_{j} \oplus i$ 一定有前面 $k$ 位都是相同的，从 $k + 1$ 位开始不同。但这样的话需要 $i, j$ 两个参数，我们需要奇妙地转化。

设 $a_{i}, j, a_{j}, i$ 的前 $k$ 位分别为 $A, B, C, D$ ，则

A \oplus B = C \oplus D .

移项得

A \oplus D = B \oplus C .

对于第 $k + 1$ 位，同样分别设 $A, B, C, D$ 。因为此时 $A \oplus B < C \oplus D$ ，所以 $A \oplus B = 0$ ， $C \oplus D = 1$ 。所以 $A = B = C$ 或 $A = B = D$ 。

若 $A = B = C$ ，则 $A \oplus D = 1$ ， $B \oplus C = 0$ ；
若 $A = B = D$ ，则 $A \oplus D = 0$ ， $B \oplus C = 1$ 。

我们发现它们得到答案一定是两个数位的值不同，至此我们转化为了只需要一个参数的问题。

我们在学习 Trie 的时候就知道，异或运算由于其特性，可以转到 Trie 树上维护最大值。刚才我们得到了

a_{i} \oplus i = a_{j} \oplus j,

于是我们把每个 $a_{i} \oplus i$ 扔到 Trie 里面，每次在 Trie 树相反的一方查询最大值。

constexpr int MAXN=3e5+5;
int T,n,a[MAXN],ans;
int f[MAXN],trie[MAXN<<5][2],mx[MAXN<<5][2],tot=1;
void insert(int x,int val){
	int now=1,p=a[x]^(x-1);
	for(int j=30;~j;--j){
		bool bp=p>>j&1,bx=(x-1)>>j&1;
		if(!trie[now][bp]) trie[now][bp]=++tot;
		mx[trie[now][bp]][bx]=max(mx[trie[now][bp]][bx],val);
		now=trie[now][bp];
	}
}
int query(int x){
	int now=1,p=a[x]^(x-1),res=0;
	for(int j=30;~j;--j){
		bool bp=p>>j&1,bx=a[x]>>j&1;
		if(trie[now][!bp]) res=max(res,mx[trie[now][!bp]][!bx]);
		if(trie[now][bp]) now=trie[now][bp];
		else break;
	}
	return res;
}

int main(){
	T=read();
	while(T--){
		n=read();
		ans=0;
		for(int i=1;i<=n;++i) a[i]=read();
		for(int i=1;i<=n;++i){
			f[i]=query(i)+1;
			insert(i,f[i]);
			ans=max(ans,f[i]);
		}
		write(ans);
		for(int i=1;i<=tot;++i) trie[i][0]=trie[i][1]=mx[i][0]=mx[i][1]=0;
		tot=1;
	}
	return fw,0;
}

T8 [CF1876F] Indefinite Clownfish

一道真正的黑题。逃。

T9 [CF193D] Two Segments

线段树维护值域区间。

一般对于这种 “公差为 $1$ 的等差数列”，就应该想到化枚举区间为枚举值域区间。于是问题转化为在连续的一段值域上，这些值域组成的连续段 $\leq 2$ 的方案数。（注意是小于等于 $2$ ，因为等于 $1$ 说明剩下的一部分也是等差数列。处理算重问题会讲。）

对于这种区间问题，一般来说是一个一个 “加入”，然后统计答案。关键在于，我们需要维护每个加入点对总区间数的影响。如果加入的这个 $i$ 在原来序列中的位置：

左右两边的数都比 $i$ 小，也就是它们原本都是在 $[1, i]$ 之内的，这时 $i$ 的加入相当于连接了原本的两个区间，会使得区间个数 $- 1$ ；
左右两边的数一个比 $i$ 大、一个比 $i$ 小，相当于扩展了原区间，则区间个数不变；
都比 $i$ 大，相当于用原本的一个区间一次扩展了两个区间，区间个数 $+ 1$ 。

具体实现上来说，我们按照 $1 \sim n$ 枚举值域右端点，每次枚举到一个新的 $i$ 时，先假设当前点需要再分一块连续段，于是 $mdf (1, i, 1)$ 。然后依次判断 $i$ 在原序列位置左右两端的数，有一个小于就 $mdf (1, a [p_{i} - 1], - 1)$ 或 $mdf (1, a [p_{i} + 1], - 1)$ 。最后统计的是 $\sum query (1, i - 1)$ 。

为什么是 $i - 1$ 呢，因为 $i - 1$ 是你保证完全处理好的，如果查 $query (1, i)$ 则不确定 $i$ 是否还会被 $i + 1$ 更新，所以每一次查询上一位。不能查询 $query (1, n)$ ，因为 $1 \sim n$ 无非是从中间任劈两半，而这些情况我们之前都算过了。

以上，就是我对这道题、对线段树维护区间的浅薄理解。

#define lp p<<1
#define rp p<<1|1
using ll=long long;
constexpr int MAXN=3e5+5;
int n,a[MAXN],p[MAXN];
ll ans;
struct{
	ll mn,lazy,tm,ctm;
}st[MAXN<<2];
ll min(ll a,ll b){
	return a<b?a:b;
}
void pushup(int p){
	st[p].mn=min(st[lp].mn,st[rp].mn);
	st[p].tm=st[lp].tm*(st[lp].mn==st[p].mn)+st[rp].tm*(st[rp].mn==st[p].mn);
	st[p].ctm=st[lp].ctm*(st[lp].mn==st[p].mn)+st[lp].tm*(st[lp].mn==st[p].mn+1)+st[rp].ctm*(st[rp].mn==st[p].mn)+st[rp].tm*(st[rp].mn==st[p].mn+1);
}
void build(int s,int t,int p){
	if(s==t) return st[p].tm=1,void();
	int mid=(s+t)>>1;
	build(s,mid,lp),build(mid+1,t,rp);
	pushup(p);
}
void pushdown(int p){
	if(!st[p].lazy) return;
	st[lp].mn+=st[p].lazy;
	st[lp].lazy+=st[p].lazy;
	st[rp].mn+=st[p].lazy;
	st[rp].lazy+=st[p].lazy;
	st[p].lazy=0;
}
void mdf(int l,int r,ll k,int s=1,int t=n,int p=1){
	if(l>t||s>r) return;
	if(l<=s&&t<=r) return st[p].mn+=k,st[p].lazy+=k,void();
	pushdown(p);
	int mid=(s+t)>>1;
	mdf(l,r,k,s,mid,lp),mdf(l,r,k,mid+1,t,rp);
	pushup(p);
}
int sum(int l,int r,int s=1,int t=n,int p=1){
	if(l>t||s>r) return 0;
	if(l<=s&&t<=r) return st[p].tm*(st[p].mn<=2)+st[p].ctm*(st[p].mn<=1);
	pushdown(p);
	int mid=(s+t)>>1;
	return sum(l,r,s,mid,lp)+sum(l,r,mid+1,t,rp);
}

int main(){
	n=read();
	for(int i=1;i<=n;++i) a[i]=read(),p[a[i]]=i;
	build(1,n,1);
	for(int i=1;i<=n;++i){
		mdf(1,i,1);
		if(a[p[i]-1]<i&&a[p[i]-1]) mdf(1,a[p[i]-1],-1);
		if(a[p[i]+1]<i&&a[p[i]+1]) mdf(1,a[p[i]+1],-1);
		ans+=sum(1,i-1);
	}
	printf("%lld\n",ans);
	return 0;
}

T10 [AGC056C] 01 Balanced

竟然是一道差分约束题。~~逼我补差分约束是吧。~~

看到要满足 $m$ 个条件，便隐约有点图论的影子。要求 $[l_{i}, r_{i}]$ 的 $01$ 字符相同，于是设 $d (i)$ 为 $1 \sim i$ 中 $0$ 的个数减去 $1$ 的个数，给定条件转化为

d (r_{i}) = d (l_{i} - 1) .

又因为 $\forall i \in (1, n]$ ， $| d (i) - d (i - 1) | \leq 1$ ，所以差分约束就出来了：

{\begin{cases} d (l_{i} - 1) = d (r_{i}) & \forall i \in [1, m]; \\ d (r_{i}) = d (l_{i} - 1) & \forall i \in (1, n] . \end{cases}

同时，差分约束还能很好地满足 “最小化原串字典序” 的需要。因为原串字典序最小，所以原串的 $0$ 越靠前越好，所以 $d (i)$ 的字典序越大越好。用差分约束只需要建好边就可以。

具体而言，建所有 $(l_{i} - 1, r_{i})$ 、边权为 $0$ 的双向边；建所有 $(i - 1, i)$ 、边权为 $1$ 的双向边。由于边权的特殊性，我们无需最短路算法，只需 01BFS 即可在 $O (n + m)$ 的时间内解决本题。

constexpr int MAXN=1e6+5;
int n,m,head[MAXN],tot,dis[MAXN];
struct{
	int v,to,w;
}e[MAXN<<2];
void addedge(int u,int v,int w){
	e[++tot]={v,head[u],w};
	head[u]=tot;
}
void bfs(){
	memset(dis,-1,sizeof(int)*(n+5));
	dis[0]=0;
	deque<int>q;
	q.emplace_back(0);
	while(!q.empty()){
		int u=q.front();
		q.pop_front();
		for(int i=head[u];i;i=e[i].to){
			if(~dis[e[i].v]) continue;
			dis[e[i].v]=dis[u]+e[i].w;
			e[i].w?q.emplace_back(e[i].v):q.emplace_front(e[i].v);
		}
	}
}

int main(){
	n=read(),m=read();
	for(int i=1;i<=n;++i) addedge(i,i-1,1),addedge(i-1,i,1);
	for(int i=1,l,r;i<=m;++i){
		l=read(),r=read();
		addedge(l-1,r,0),addedge(r,l-1,0);
	}
	bfs();
	for(int i=1;i<=n;++i) write(dis[i]-dis[i-1]<0,'#');
	return putchar('\n'),fw,0;
}

posted @ 2024-11-24 22:04 Laoshan_PLUS 阅读(6) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 暑期模拟赛总结（上）

· 2025 提高刷题 - DP

· Hello 2024

· CSP提高组模拟1

· Recent 做题记录（你先别急）

阅读排行：
· winform 绘制太阳，地球，月球运作规律
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· AI 智能体引爆开源社区「GitHub 热点速览」
· Manus的开源复刻OpenManus初探
· 写一个简单的SQL生成工具

laoshan-plus

2024 提高组杂题

2024 提高组杂题

T1 [CF1763C] Another Array Problem

T2 [CF1775E] The Human Equation

T3 [CF1290C] Prefix Enlightenment

T4 [CF1458D] Flip and Reverse

T5 [CF1389F] Bicolored Segments

T6 [CF1580D] Subsequence

T7 [CF1720D2] Xor-Subsequence (hard version)

T8 [CF1876F] Indefinite Clownfish

T9 [CF193D] Two Segments

T10 [AGC056C] 01 Balanced

公告

搜索

常用链接

最新随笔

我的标签

积分与排名

合集 (7)

随笔分类 (84)

随笔档案 (85)

文章分类 (18)

文章档案 (18)

相册 (20)

OI常用工具网站

灌水区

阅读排行榜

评论排行榜

推荐排行榜

最新评论