2023.7.11 NOIP模拟赛

破防了 混个 100 怎么这么难

---

赛时记录

A 没看懂 难绷
B 没思路
C 什么是割 直接放吧
D 看懂了 但是好难

A后来附加了解释 终于看懂了 但还是很懵
看到数据范围应该是 $O(n)$ 的 那每一项要么是单独 $O(1)$ 要么是递推 应该是后者
那么我们考虑 $i$ 插入对 $i-1$ 的影响

9:26 70pts的 $O(n^2)$ 想出来了 但是希望别挂
9:44 写完了 熟悉的大样例寄掉了
9:45 大样例调过了！！！

D猜测正解或者说很大部分的部分分和运输计划很像 二分答案+树上差分
但是我的评价是我能码出来 $O(n^{2}logn)$ 那个就不错了
结果一顿捣鼓发现我靠假了 是 $O(n^{3}logn)$ 很寄
10:33 码完了 大样例又双叒叕寄了
发现链不只是从上到下的 开摆！
改完了 然后调不出来了 还是捆测 我谔谔
又改完了 但是不知道为啥 T 了
怄火 恼怒 转圈 怄火 恼怒 转圈 怄火 恼怒 转圈 怄火 恼怒 转圈 怄火 恼怒 转圈 怄火 恼怒 转圈 怄火 恼怒 转圈 怄火 恼怒 转圈
破防了 为什么我这么菜 破防了 为什么我这么菜 破防了 为什么我这么菜 破防了 为什么我这么菜 破防了 为什么我这么菜 破防了 为什么我这么菜

预计：70 + 0 + 0 + 0
实际：70 + 0 + 0 + 0 rk8

补：

upd：吸了八聚氧变成了 14.36s 但还是没什么卵用

---

补题

A.

这里先贴一下 $70pts$ 的赛时代码：

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

const int N = 2e5 + 0721;
ll f[N], fac[N], c[N][2], v[N];
int k;
ll inv, ans;
ll mod;
int n;

ll ksm(ll x, ll y) {
	ll ret = 1;
	while (y) {
		if (y & 1) ret = ret * x % mod;
		x = x * x % mod;
		y >>= 1;
	}
	return ret;
} 

void init() {
	fac[0] = fac[1] = 1;
	for (int i = 2; i <= n; ++i) fac[i] = fac[i - 1] * i % mod;
}

void dp(int m) {
	k = k ^ 1;
	for (int i = 1; i <= m; ++i) c[i][k] = (c[i - 1][k ^ 1] + c[i + 1][k ^ 1] * (i + 1) % mod) % mod;
	c[0][k] = c[1][k ^ 1];
	ll sum = 0;
	for (int i = 0; i <= m; ++i) sum = (sum + ((i + 1) * c[i][k]) % mod) % mod;
	v[m] = ((fac[m + 1] - sum) % mod + mod) * inv % mod;
	ans ^= v[m];
}

int main() {
	
	scanf("%d%lld", &n, &mod);
	
	c[0][k] = 1;
	inv = ksm(2, mod - 2);
	init();
	for (int i = 1; i < n; ++i) dp(i);
	printf("%lld", ans);
	
	return 0;
}

主要是这段讲起来很麻烦想起来也挺麻烦所以就摆了
后面其实偏了 主要是过分注意转移差值发现柿子错了
实际上我们观察一下这个图

发现红色其实就是 $f_{i-1}$
蓝色就是把 $f_2$ 乘了 $3$ 倍
那如果继续画下去 画到第五个 其实转移式就出来了
$f_i=f_{i-1}\ast f_{i-2}\ast (i-1)$
没错 就是这么简单的一个玩意（吐血）
code：

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

const int N = 1e7 + 0721;
ll f[N], fac[N], v[N];
int k;
ll inv, ans;
ll mod;
int n;

ll ksm(ll x, ll y) {
	ll ret = 1;
	while (y) {
		if (y & 1) ret = ret * x % mod;
		x = x * x % mod;
		y >>= 1;
	}
	return ret;
} 

void init() {
	fac[0] = fac[1] = 1;
	for (int i = 2; i <= n; ++i) fac[i] = fac[i - 1] * i % mod;
}

void dp(int m) {
	f[m] = (f[m - 1] + f[m - 2] * (m - 1) % mod) % mod;
	v[m] = ((fac[m] - f[m]) % mod + mod) * inv % mod;
	ans ^= v[m];
}

int main() {
//	freopen("ex_perm1.in", "r", stdin);
	
	scanf("%d%lld", &n, &mod);
	
	f[0] = f[1] = 1;
	inv = ksm(2, mod - 2);
	init();
	for (int i = 2; i <= n; ++i) dp(i);
	printf("%lld", ans);
	
	return 0;
}

B.

与我也忘了昨天的哪道题一样 我们算贡献
即计算当这个最大值为 $k$ 的时候的染色方案数 乘起来就是对应的贡献
首先这题要求的是两点间最大距离 考虑直径
如果直径的两个端点同色 那么别的点怎么染色都行
我们考虑直径的两个端点不同的情况 考虑此时两同色点之间的最距离为 $k$
那么对于一个点而言 与它距离的最大值点一定出现在直径的两个端点
那么如果假如说这个点到那个黑端点的距离为 $d$ 并且 $d>k$ 那么这个点就只能是白的
反过来也是同理的
如果这个点到两个端点的距离都不超过 $k$ 那它就是涂什么颜色都可以的
如果到两个端点的距离都大于 $k$ 那就没有合法方案数了 并且更小的 $k$ 也没有合法方案数了
所以我们从直径的两个端点做一边 $dfs$ 维护这个距离即可
$std$ 统计答案的时候用了一种很新的写法
code：

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

const int mod = 1e9 + 7;
const int N = 1e6 + 0721;
int x1, x2;
int head[N], nxt[N << 2], to[N << 2], cnt;
int dis[N];
int c[N];
bool vis[N];
int n, ans;

struct node {
	int dis1, dis2;
} a[N];

inline void add_edge(int x, int y) {
	to[++cnt] = y;
	nxt[cnt] = head[x];
	head[x] = cnt;
}

int ksm(int x, int y) {
	int ret = 1;
	while (y) {
		if (y & 1) ret = 1ll * ret * x % mod;
		x = 1ll * x * x % mod;
		y >>= 1;
	}
	return ret;
}

void dfs(int x, int fa) {
	for (int i = head[x]; i; i = nxt[i]) {
		int y = to[i];
		if (y == fa) continue;
		dis[y] = dis[x] + 1;
		dfs(y, x);
	}
}

void dfs1(int x, int fa) {
	for (int i = head[x]; i; i = nxt[i]) {
		int y = to[i];
		if (y == fa) continue;
		a[y].dis1 = a[x].dis1 + 1;
		dfs1(y, x);
	}
}

void dfs2(int x, int fa) {
	for (int i = head[x]; i; i = nxt[i]) {
		int y = to[i];
		if (y == fa) continue;
		a[y].dis2 = a[x].dis2 + 1;
		dfs2(y, x);
	}
}

void find_d() {
	dfs(1, 0);
	for (int i = 1; i <= n; ++i) if (dis[i] > dis[x1]) x1 = i;
	dis[x1] = 0;
	dfs(x1, 0);
	for (int i = 1; i <= n; ++i) if (dis[i] > dis[x2]) x2 = i;
}

void find_dis() {
	dfs1(x1, 0);
	dfs2(x2, 0);
}

void solve() { //就这块
	int maxn = dis[x2];
	int sum = ksm(2, n);
	int num = n + 1;
	for (int i = maxn; i >= 0; --i) {
		if (vis[i]) {
			ans = (ans + 1ll * i * sum % mod) % mod;
			printf("%d", ans);
			return;
		}
		num -= c[i];
		int tmp = ksm(2, num);
		ans = (ans + 1ll * i * (sum - tmp + mod) % mod) % mod;
		sum = tmp;
	}
}

int main() {
//	freopen("ex_tree2.in", "r", stdin);
	
	scanf("%d", &n);
	for (int i = 1; i < n; ++i) {
		int x, y;
		scanf("%d%d", &x, &y);
		add_edge(x, y);
		add_edge(y, x);
	}
	
	find_d();
	find_dis();
	
	for (int i = 1; i <= n; ++i) {
		++c[a[i].dis1];
		++c[a[i].dis2];
		vis[min(a[i].dis1, a[i].dis2)] = 1;
	}
	
	solve();
	
	return 0;
}

C.

这题。。。你想到了就想到了 想不到就没办法了
首先对于一个图的 $k$ 度子图 它一定是不相交的一坨一坨一坨
因为如果相交 那么两个相交的一坨会构成一坨更大的 $k$ 度子图
然后我们考虑枚举 $k$ 并把此时的答案算出来
那么我们发现这个图中所有度数小于 $k$ 的点都会被删掉
所以我们先把这些点都删掉 然后把与它相邻的点也减一下度数

然后考虑 因为我们要枚举 $k$ 我们显然要求出每个 $k$ 图中的联通情况 或者说删了哪些点
然后我们发现 显然 $k$ 越大 删掉的点就越多
并且当 $k=i$ 时 删的点一定是基于 $k=i-1$ 那张图的基础上的
所以我们记录下当前 $k$ 新删的点就可以了
最后统计的时候我们倒过来加点 然后用并查集维护
这个求割也是一种很新的方式
code：

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

const int maxn = 1e6 + 0721;
int v[maxn], e[maxn], d[maxn]; //点数 边数 deg
int deg[maxn], fa[maxn];
int head[maxn], nxt[maxn << 2], to[maxn << 2], cnt;
vector<int> q[maxn];
bool vis[maxn], exist[maxn];
int M, N, B;
int n, m;

inline void add_edge(int x, int y) {
	to[++cnt] = y;
	nxt[cnt] = head[x];
	head[x] = cnt;
} 

int find(int x) {
	return fa[x] == x ? x : fa[x] = find(fa[x]);
}

void merge(int x, int y) {
	int fx = find(x), fy = find(y);
	++e[fx];
	if (fx == fy) return;
	d[fx] += d[fy];
	e[fx] += e[fy];
	v[fx] += v[fy];
	fa[fy] = fx;
}

ll calc(int x) {
	int fx = find(x);
	return 1ll * M * e[fx] - 1ll * N * v[fx] + 1ll * B * (d[fx] - (e[fx] << 1));
}

int main() {
//	freopen("ex_data2.in", "r", stdin);
	
	scanf("%d%d", &n, &m);
	scanf("%d%d%d", &M, &N, &B);
	for (int i = 1; i <= m; ++i) {
		int x, y;
		scanf("%d%d", &x, &y);
		add_edge(x, y);
		add_edge(y, x);
		++deg[x], ++deg[y];
	}
	
	for (int i = 1; i <= n; ++i) {
		q[deg[i]].push_back(i);
		d[i] = deg[i];
		fa[i] = i;
		v[i] = 1;
	}
	
	for (int i = 1; i <= n; ++i) {
		int len = 0;
		for (int j = 0; j < q[i].size(); ++j) {
			int id = q[i][j];
			if (vis[id]) continue;
			q[i][len] = id;
			++len;
			vis[id] = 1;
			for (int k = head[id]; k; k = nxt[k]) {
				int y = to[k];
				if (vis[y]) continue; //已经被删掉了
				--deg[y];
				q[max(i, deg[y])].push_back(y); //如果原来deg等于i或者删完是i 都要在这波删掉 等会循环到它的时候就会把它记录到 
			}
		}
		q[i].resize(len);
	}
	
	ll maxx = -0x7ffffffffffffff;
	int ans;
	for (int i = n; i >= 1; --i) {
		for (int u : q[i]) {
			exist[u] = 1; //把这个点还原 
			for (int j = head[u]; j; j = nxt[j]) {
				int y = to[j];
				if (exist[y]) merge(u, y); //如果这个点存在 
			}
		}
		for (int u : q[i]) {
			ll val = calc(u);
			if (val > maxx) {
				maxx = val;
				ans = i;
			}
		}
	}
	
	printf("%d %lld", ans, maxx);
	
	return 0;
}

D.

不会长链剖分 看不懂题解 再说吧