暑假集训CSP提高模拟4

合集 - 赛事(59)

1.Codeforces Round 955 (Div. 2)2024-06-262.AtCoder Beginner Contest 3632024-07-213.AtCoder Regular Contest 182（A B C）2024-08-124.暑假集训CSP提高模拟12024-07-185.暑假集训CSP提高模拟22024-07-196.暑假集训CSP提高模拟72024-07-257.暑假集训CSP提高模拟52024-07-238.暑假集训 加赛12024-07-22

9.暑假集训CSP提高模拟42024-07-21

10.暑假集训CSP提高模拟182024-08-1111.暑假集训CSP提高模拟172024-08-1012.暑假集训CSP提高模拟 162024-08-0813.暑假集训CSP提高模拟 ∫[0,6] (x^2)/6 dx2024-07-3114.暑假集训CSP提高模拟112024-07-2915.暑假集训SCP提高模拟102024-07-2816.暑假集训PVZ提高模拟92024-07-2717.暑假集训CSP提高模拟82024-07-2618.暑集假训SCP提高拟模212024-08-1519.[CL-FOOL] CLOI 愚人赛的部分官方题解与小杂谈2024-04-0220.トヨタ自動車プログラミングコンテスト2024#7（ABC 362）2024-07-1421.寒假集训测试2 题目转存2024-02-2322.HEOI2024 题目转存2024-03-0523.高一小学期22024-07-0824.张江蔡2024-06-2725.高一高考集训总结赛2024-06-1326.高一下二调题目转存2024-04-1527.CSP提高组模拟12024-07-1228.Atcoder Beginner Contest 3672024-08-1829.[R18][中国語翻訳]HDKのABC370赛試（ABC370）2024-09-0830.[30] CSP 加赛 12024-09-1531.[33]（CSP 集训）CSP-S 模拟 42024-09-2532.[34]（CSP 集训）CSP-S 联训模拟 12024-09-2633.[35] (CSP 集训) CSP-S 模拟 52024-09-2734.[36]（CSP 集训）CSP-S 模拟 62024-09-2835.AtCoder Beginner Contest 3732024-09-2936.[37]（CSP 集训）CSP-S 模拟 72024-09-3037.[39] (多校联训) A层冲刺NOIP2024模拟赛012024-10-0338.[40]（CSP 集训）CSP 联训模拟 22024-10-0539.[42] (多校联训) A层冲刺NOIP2024模拟赛032024-10-0740.[41] (CSP 集训) CSP-S 模拟 92024-10-0741.[44] (多校联训) A层冲刺NOIP2024模拟赛042024-10-0942.[45] (多校联训) A层冲刺NOIP2024模拟赛052024-10-1143.[46] (多校联训) A层冲刺NOIP2024模拟赛062024-10-1244.パナソニックグループ プログラミングコンテスト2024（ABC 375）2024-10-1345.[47] (CSP 集训) CSP-S 模拟 112024-10-1446.[49 & 50] (多校联训) A层冲刺NOIP2024模拟赛08 | CSP-S 模拟 122024-10-1847.[51] (多校联训) A层冲刺NOIP2024模拟赛092024-10-1948.Atcoder Beginner Contest 3762024-10-2049.Codeforces Round 980 (Div. 2)2024-10-2050.[54] (多校联训) A层冲刺NOIP2024模拟赛122024-10-2451.[57] (多校联训) A层冲刺NOIP2024模拟赛152024-10-2952.[61] (多校联训) A层冲刺NOIP2024模拟赛182024-11-0553.[62] (NOIP 集训) NOIP2024加赛 22024-11-0654.[63] (多校联训) A层冲刺NOIP2024模拟赛192024-11-0755.[68] (炼石计划) NOIP 模拟赛 #202024-11-1456.[68] (NOIP集训) NOIP2024 加赛 52024-11-2057.[72] (多校联训) A层冲刺NOIP2024模拟赛252024-11-2258.[73] (NOIP集训) NOIP2024 加赛 72024-11-2259.[75] (NOIP集训) NOIP2024 加赛 82024-11-27

收起

A.White and Black

暴力的 $O(nq)$ 做法比较显然，因为对于根节点来说，只有它自己可以改变自己的颜色，因此如果它是黑色则一定需要更改自己，同时把更改传下去（应该没有那种每次真的更改所有节点然后写 $O(nq{n}^n)$ 的吧），同理，假如根节点更改结束，次级节点就同理了，这是一个连锁的反应，因此搜一遍下来就行了.

这道题的优化点主要是在减少白点的枚举次数上，注意到数据范围中给出的黑点数量非常少，因此我们考虑将枚举白点变成枚举子节点总数减去黑点总数，这样就能把复杂度降下来.

这样还是不好做，考虑预处理出每个节点的儿子总数，如果节点变黑，则其每个儿子对它作 $1$ 的贡献，如果儿子也是黑色的，说明该儿子不再对该父节点做贡献，临时减掉即可.

这道题写了部分分但是没拿到，因为题目里只说了是菊花，没说根节点是谁，判断的时候漏判了.

#include<bits/stdc++.h>
using namespace std;
int n,q;
int sons[200001],fa[200001],black[200001],isblack[200001];
int main(){
	scanf("%d %d",&n,&q);
	for(int i=2;i<=n;++i){
		scanf("%d",&fa[i]);
		sons[fa[i]]++;
	}
	for(int i=1;i<=q;++i){
		int x;
		scanf("%d",&x);
		int ans=0;
		for(int j=1;j<=x;++j){
			scanf("%d",&black[j]);
			isblack[black[j]]=true;
		}
		for(int j=1;j<=x;++j){
			ans+=sons[black[j]];
		}
		for(int j=1;j<=x;++j){
			if(!isblack[fa[black[j]]]) ans++;
			else ans--;
		}
		printf("%d\n",ans);
		for(int j=1;j<=x;++j){
			isblack[black[j]]=false;
		}
	}
}

B.White and White

还是比较显然的 $O(n^{2}k)$ 暴力，对于此题显然可以设计 $f_{i,j}$ 表示选到第 $j$ 位，上次划分在 $i$ 位置的最小值，可以得到：

$$f_{i,j}=\underset{1\le k<j}{min}\{f_{i-1,k}+(\sum _{k+1\le x\le j}^x{a}_x)\mathrm{mod}p\}$$

发现这个 $\mathrm{mod}p$ 非常恶心，阻止我们进一步使用优先队列进行优化.

因此考虑从这个 $\mathrm{mod}p$ 入手，因为我们每次进行取模都只是剪掉了一个 $kp(k\in Z)$，即 $f_{i,j}\equiv \sum _{1\le x\le j}^x{a}_x(\mathrm{mod}p)$

在我们进行状态转移时（即上式），对于两个 $k=a,b$，将同余式传递，有

$$f_{i,j}\equiv f_{i-1,a}+\sum _{a\le x\le j}^x{a}_x\equiv f_{i-1,b}+\sum _{b\le x\le j}^x{b}_x(\mathrm{mod}p)$$

假设当 $f_{i-1,a}+\sum _{a\le x\le j}^x{a}_x<f_{i-1,b}+\sum _{b\le x\le j}^x{b}_x$ 时，有 $f_{i-1,a}<f_{i-1,b}$，此时移项有：

$$\sum _{a\le x\le j}^x{a}_x<f_{i-1,b}+\sum _{b\le x\le j}^x{b}_x-f_{i-1,a}$$

刚才我们知道

$$\sum _{a\le x\le j}^x{a}_x\equiv f_{i-1,a}-f_{i-1,b}+\sum _{b\le x\le j}^x{b}_x(\mathrm{mod}p)$$

这两个方程联立无解，因此假设不成立，我们得到：

$$f_{i-1,a}+\sum _{a\le x\le j}^x{a}_x<f_{i-1,b}+\sum _{b\le x\le j}^x{b}_x\to f_{i-1,a}\ge f_{i-1,b}$$

通过此式判断最优决策点即可

此外本题卡空间，需要用滚动数组进行优化

#include<bits/stdc++.h>
using namespace std;
int n,k,p;
const int mod=1e9+7,inf=0x3f3f3f3f;
int sum[500001];
int f[500001][101];
int g[2][101]; //维护决策最小值
int main(){
	cin>>n>>k>>p;
	memset(f,0x3f,sizeof f);
	for(int i=1;i<=n;++i){
		int x;cin>>x;
		sum[i]=(sum[i-1]+x)%p;
		f[0][0]=0;
	}
	for(int i=1;i<=n;++i){
		for(int j=1;j<=k;++j){
			f[i][j]=f[g[i&1][j-1]][j-1]+((sum[i]-sum[g[i&1][j-1]])%p+p)%p;
		}
		for(int j=0;j<=k;++j){
			if(f[i][j]<f[g[i&1][j]][j]) g[!(i&1)][j]=i;
			else g[!(i&1)][j]=g[i&1][j];
		}
	}
	cout<<f[n][k]<<endl;
}

UPD： 刚刚发现其实决策数组只需要开一维就行了

#include<bits/stdc++.h>
using namespace std;
int n,k,p;
const int mod=1e9+7,inf=0x3f3f3f3f;
int sum[500001];
int f[500001][101];
int g[101];
int main(){
	cin>>n>>k>>p;
	memset(f,0x3f,sizeof f);
	for(int i=1;i<=n;++i){
		int x;cin>>x;
		sum[i]=(sum[i-1]+x)%p;
		f[0][0]=0;
	}
	for(int i=1;i<=n;++i){
		for(int j=1;j<=k;++j){
			f[i][j]=f[g[j-1]][j-1]+((sum[i]-sum[g[j-1]])%p+p)%p;
		}
		for(int j=0;j<=k;++j){
			if(f[i][j]<f[g[j]][j]) g[j]=i;
		}
	}
	cout<<f[n][k]<<endl;
}

C.Black and Black

显然我们首先随便构造一组，只需要满足单调递增性质即可.

注意到，假如此时 $ans>0$，我们可以寻找一个位置 $j$ 满足 $\sum _{1\le i\le j}^i{a}_i=1$，这样的话，我们就可以对区间 $[1,j]$ 中的每个元素都减去 $ans$，这样结果就会变为 $ans-\sum _{1\le i\le j}^i(a_i\times ans)=0$，同时不会改变我们构造的单调递减的性质，或者，我们也可以选择一个位置 $j$ 满足 $\sum _{j\le i\le n}^i{a}_i=-1$，证明同理.

对于 $ans<0$，只需要选择 $j$ 满足 $\sum _{1\le i\le j}^i{a}_i=-1$ 或 $\sum _{j\le i\le n}^i{a}_i=1$ 即可.

若不存在上述情况，即为无解.

#include<bits/stdc++.h>
using namespace std;
#define int long long
int n;
int a[200001],b[200001];
int foresum,backsum,fore,back;
void randcreate(){
	for(int i=1;i<=n;++i){
		b[i]=i;
	}
}
int cal(){
	int ans=0;
	for(int i=1;i<=n;++i){
		ans+=a[i]*b[i];
//		cout<<a[i]<<" * "<<b[i]<<endl;
	}
//	cout<<ans<<endl;
	return ans;
}
signed main(){
	cin>>n;
	for(int i=1;i<=n;++i){
		cin>>a[i];
	}
	randcreate();
	int res=cal();
	if(res==0){
		cout<<"Yes"<<endl;
		for(int i=1;i<=n;++i){
			cout<<b[i]<<" ";
		}
		cout<<endl;
		return 0;
	}
	else if(res>0){
		for(fore=1;fore<=n;++fore){
			foresum+=a[fore];
			if(foresum>0) break;
		}
		for(back=n;back>=1;--back){
			backsum+=a[back];
			if(backsum<0) break;
		}
//		cout<<fore<<" : "<<back<<endl;
		if(fore!=n+1) for(int i=1;i<=fore;++i) b[i]-=res;
		else if(back!=0) for(int i=back;i<=n;++i) b[i]+=res;
		else{
			cout<<"No"<<endl;
			return 0;
		}
	}
	else{
		for(fore=1;fore<=n;++fore){
			foresum+=a[fore];
			if(foresum<0) break;
		}
		for(back=n;back>=1;--back){
			backsum+=a[back];
			if(backsum>0) break;
		}
//		cout<<fore<<" : "<<back<<endl;
		if(fore!=n+1) for(int i=1;i<=fore;++i) b[i]+=res;
		else if(back!=0) for(int i=back;i<=n;++i) b[i]-=res;
		else{
			cout<<"No"<<endl;
			return 0;
		}
	}
	cout<<"Yes"<<endl;
	for(int i=1;i<=n;++i){
		cout<<b[i]<<" ";
	}
	cout<<endl;
}

D.Black and White

最暴力的做法是单次 $n^2$ 枚举点对求距离最大值. $O(q{n}^2\log n)$

比较暴力的显然是直接单次两遍 DFS 求树的直径. $O(q{n}^2)$

直接说正解，考虑到根据原树的 DFS 序将整棵树压缩成一个括号序列. $O(q\log n)$

注意到，自身封闭的括号序列一定是一颗完整的子树，因此，当我们需要求解 $x,y$ 之间的距离时，应该考虑分别找到 $x,y$ 的位置，然后提取出 $[po{s}_x,po{s}_y]$ 之间的括号序列. 假如该序列中存在封闭的子括号序列，说明最短路径显然不会进入这颗子树（因为 $x,y$ 均不在这个子树内，因此走进去是多余的），所以考虑消去路径上全部封闭的子括号序列，余下的括号个数即为路径长.

显然，这样的复杂度不够优秀，注意到区间括号序列是具有可合并性的，当我们合并两个括号序列的时候，根据上述所需，我们完全可以预先消去两个子区间内的全部封闭子括号序列，其次进行合并，再将新形成的括号序列继续与其他括号序列进行合并.

基于这样的思想，我们使用线段树来维护消除完毕的括号序列（即任意两点间距离，通过查询 $[l,r]$ 区间和即可获得 $di{s}_{l,r}$）.

显然我们需要维护的有：DFS 序，各点在 DFS 序列上的位置，线段树（存储每个区间的左括号数目，右括号数目（特别地，由于维护跨区间距离的需要，我们还需要维护该树的子树的括号情况），以及该区间左右端点间距离（即剩余括号数））.

此外还需要判 $-1$ 和 $0$，记一个 $cnt$ 即可.

#include<bits/stdc++.h>
using namespace std;
const int inf=1e9;
int num,s[3000001],pos[1000001];
int n,m;
int cnt,tot;
bool c[100001];
vector<int>e[200001];
void dfs(int now,int fa){
	s[++tot]=-1;
	s[++tot]=now;
	pos[now]=tot;
	for(int i:e[now]){
		if(i!=fa){
			dfs(i,now);
		}
	}
	s[++tot]=-2;
}
#define tol (id*2)
#define tor (id*2+1)
#define mid(l,r) mid=((l)+(r))/2
struct tree{
	int a,b;
	int l1,l2,r1,r2;
	int dis;
}t[1200005];
void push(int id,int x){
	t[id].a=t[id].b=0;
	t[id].l1=t[id].l2=t[id].r1=t[id].r2=t[id].dis=-inf;
	if(s[x]==-1){
		t[id].b=1;
	}
	else if(s[x]==-2){
		t[id].a=1;
	}
	else if(!c[s[x]]){
		t[id].l1=t[id].r1=t[id].r2=t[id].l2=0;
	}
}
void merge(int id){
	if(t[tol].b>t[tor].a){
		t[id].a=t[tol].a,t[id].b=t[tol].b-t[tor].a+t[tor].b;
	}
	else{
		t[id].a=t[tol].a+t[tor].a-t[tol].b,t[id].b=t[tor].b;
	}
	t[id].l1=max({t[tol].l1,t[tor].l1+t[tol].a-t[tol].b,t[tor].l2+t[tol].a+t[tol].b});
	t[id].l2=max(t[tol].l2,t[tor].l2-t[tol].a+t[tol].b);
	t[id].r1=max({t[tor].r1,t[tol].r1-t[tor].a+t[tor].b,t[tol].r2+t[tor].a+t[tor].b});
	t[id].r2=max(t[tor].r2,t[tol].r2+t[tor].a-t[tor].b);
	t[id].dis=max({t[tol].r1+t[tor].l2,t[tol].r2+t[tor].l1,t[tol].dis,t[tor].dis});
}
void build(int id,int l,int r){
	if(l==r){
		push(id,l);
		return;
	}
	int mid(l,r);
	build(tol,l,mid);
	build(tor,mid+1,r);
	merge(id);
}
void modify(int id,int l,int r,int x){
	if(l==r){
		push(id,l);
		return;
	}
	int mid(l,r);
	if(x<=mid){
		modify(tol,l,mid,x);
	}
	else{
		modify(tor,mid+1,r,x);
	}
	merge(id);
}
int main(){
	scanf("%d",&n);
	cnt=n;
	for(int i=1;i<=n-1;i++){
		int x,y;
		scanf("%d%d",&x,&y);
		e[x].push_back(y);
		e[y].push_back(x);
	}
	dfs(1,0);
	build(1,1,tot); 
	scanf("%d",&m);
	for(int i=1;i<=m;i++){
		char op='\n';int x;
		while(op!='G' and op!='C') op=getchar();
		if(op=='C'){
			scanf("%d",&x);
			if(c[x]){
				c[x]=0;
				cnt++;
			}
			else{
				c[x]=1;
				cnt--;
			}
			modify(1,1,tot,pos[x]);
		}
		else if(cnt==0){
			printf("-1\n");
		}
		else if(cnt==1){
			printf("0\n");
		}
		else{
			printf("%d\n",t[1].dis);
		}
	}
}