2025 CSP-S 模拟赛 Day 16 复盘

最新推荐文章于 2025-12-22 09:47:08 发布

原创最新推荐文章于 2025-12-22 09:47:08 发布 · 930 阅读

26 ·

CC 4.0 BY-SA版权

文章标签：

#算法

T1

题意

给出一棵 $n$ 个节点的树，你需要从中选择恰好一条边删除，然后任意选择两个点 $\not = v)$ 。在 $u, v$ 之间连接一条边，满足操作完之后还是一棵树。
需要对于每个点 $i$ 求出操作结束后的树存在两个重心，并且其中一个重心是 $i$ 的方案数。

解法

分类讨论。

删除边的两端是原树的重心，加入边的两端是新树的双重心：对所有点答案的贡献为 $\frac{n}{2}$
设 $x, y$ 是原树的双重心，删除边在 $x$ 的子树内，加入边也在 $x$ 的子树内：对 $ans_x,ans_y$ 的贡献为 $\sum_u (\frac{n}{2} - size_u)$ ，其中 $u$ 在 $x$ 的子树内。
设 $x, y$ 是新树的双重心，在 $x$ 的子树中切下一个大小为 $size_x - \frac{n}{2}$ 的连通块，接入到 $y$ 的子树内：对 $ans_x,ans_y$ 的贡献为 $\sum_{u(size_u = size_x - \frac{n}{2})}size_u \times size_y$ ，其中 $u$ 在 $x$ 的子树内。

上述过程可以通过类似换根dp的方法做到 $O (n)$ 。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 5e6 + 31;
const int p = 998244353;

inline int grnd(int &s){
    s ^= s << 13;
    s ^= s >> 17;
    s ^= s << 5;
    if(s < 0) 
		s = -s;
    return s;
}

ll ksm(ll a,ll b){
	ll ans = 1;
	while(b){
		if(b & 1)
			ans = ans * a % p;
		a = a * a % p;
		b >>= 1;
	}
	return ans;
}

int n,s[N],c[N],d[N],b[N],v = 0;
ll f[N],g[N],ans[N],sum = 0;
vector<int> edge[N];

void dfs(int x,int from){
	s[x] = 1;
	for(auto y : edge[x])
		if(y != from){
			dfs(y,x); s[x] += s[y];
			f[x] = (f[x] + f[y] + 1ll * (n / 2 >= s[y] ? n / 2 - s[y] : 0) * s[y]) % p;
		}
	if(s[x] == n - s[x]){
		ans[x] += f[x];
		ans[from] += f[x];
		v = (v + s[x]) % p;
		ans[x] %= p; ans[from] %= p;
	}
}
void DfS(int x,int from){
	if(s[x] > n / 2)
		d[x] = c[s[x] - n / 2];
	c[s[x]]++;
	for(auto y : edge[x])
		if(y != from){
			g[y] = g[x] + f[x] - f[y] + 1ll * (n / 2 - (n - s[x])) * (n - s[x]);
			g[y] = (g[y] % p + p) % p; DfS(y,x);
		}
	if(s[x] == n - s[x]){
		ans[x] = (ans[x] + g[x]) % p;
		ans[from] = (ans[from] + g[x]) % p;
	}
	if(s[x] > n / 2){
		d[x] = c[s[x] - n / 2] - d[x];
		ans[x] = (ans[x] + 1ll * d[x] * (s[x] - n / 2) * (n - s[x])) % p;
		ans[from] = (ans[from] + 1ll * d[x] * (s[x] - n / 2) * (n - s[x])) % p;
	}
}
void dfS(int x,int from){
	if(s[x] < n / 2)
		d[x] = b[n / 2 - s[x]];
	b[s[x]]++;
	for(auto y : edge[x])
		if(y != from){
			c[s[x]]--; c[n - s[x]]++;
			dfS(y,x);
			if(s[y] < n / 2){
				ans[x] = (ans[x] + 1ll * d[y] * (n / 2 - s[y]) * s[y]) % p;
				ans[y] = (ans[y] + 1ll * d[y] * (n / 2 - s[y]) * s[y]) % p;
			}
			c[n - s[x]]--; c[s[x]]++;
		}
	if(s[x] < n / 2){
		d[x] = b[n / 2 - s[x]] - d[x];
		d[x] = c[n / 2 - s[x]] - d[x];
	}
}

int main(){
	int type; scanf("%d%d",&n,&type);
	if(n & 1){
		puts("0");
		return 0;
	}
	if(type == 1){
		for(int i = 1;i < n;i++){
			int u,v; scanf("%d%d",&u,&v);
			edge[u].push_back(v);
			edge[v].push_back(u);
		}
	}else{
		int a,b; scanf("%d%d",&a,&b);
		for(int i = 1;i < n;i++){
			int u = max(1,i - grnd(b) % a),v = i + 1;
			edge[u].push_back(v);
			edge[v].push_back(u);
		}
	}
	dfs(1,0); DfS(1,0); dfS(1,0);
	ll res = 0; ll tmp = 1;
	for(int i = 1;i <= n;i++){
		ans[i] += v;
		res = (res + tmp * ans[i]) % p;
		tmp = (tmp * 2333) % p;
	}
	printf("%lld\n",res);
}

T2 弱化版

题意

有一个长度为 $n$ 的序列， $q$ 次询问，每一次询问一个区间 $[l, r]$ 。

你需要构造一个二叉树，满足以下条件：

每个节点对应一个区间
根节点对应区间 $[1, n]$
叶子节点对应区间 $[i, i]$ ，同时对应区间 $[i, i]$ 的节点一定是叶子节点
每一个非叶子节点一定有两个子节点，若一个非叶子节点对应 $[i, j]$ ，那么它的两个子节点对应区间分别为 $\le k < j)$

对区间 $[l, r]$ 进行一次询问时，从根节点开始搜索，如果一个节点对应的区间被完全包含在 $[l, r]$ 中或该节点对应的区间与 $[l, r]$ 没有重叠，则不遍历其子节点，否则遍历其所有子节点。

记 $d e p$ 为遍历到的节点的最大深度， $c n t$ 为深度为 $d e p$ 的节点被遍历到的总次数，你需要在保证在 $d e p$ 最小的条件下 $c n t$ 最小，输出 $d e p$ 和 $c n t$ 。

解法

设 $f_{i,j}$ ，直接表示答案，枚举 $k$ 。若 $[i, k]$ 或者 $[k + 1, j]$ 有一个被遍历到，那么直接从 $f_{i,k}$ 和 $f_{k + 1,j}$ 继承答案；否则 $f_{i,j}$ 的最低深度就为 0，访问次数就是所有与 $[i, j]$ 有交但是并不包含的区间个数。
可以发现 $f_{i,j}$ 是具有决策单调性的，直接套用决策单调性的模板记录转移点。时间复杂度为 $O(n^2)$ 。

代码

#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 31;

map<int,int> mp;
int n,m,q,a[N],f[N][N];

int main(){
	int n,q; scanf("%d%d",&n,&q);
	for(int i = 1;i <= q;i++){
		int l,r; scanf("%d%d",&l,&r);
		if(l > 1) mp[l - 1]++;
		if(r < n) mp[r]++;
	}
	for(auto [x,y] : mp) 
        a[++m] = y;
	int d = 0;
	while(1){ 
        if((1 << d) > m) 
            break;
        d++;
    }
	if(d == 0){
        printf("%d %d\n",d,q);
        return 0;
    }
	memset(f,63,sizeof(f));
	f[0][0] = 0;
	for(int i = 1;i < (1 << d);i++){
		f[i][0] = f[i - 1][0];
		for(int j = 1;j <= m;j++)
			f[i][j] = min(f[i - 1][j],f[i - 1][j - 1] + a[j] * (i % 2));
	}
    printf("%d %d\n",d,f[(1 << d) - 1][m] * 2);
}