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 但还是没什么卵用

补题

这里先贴一下 \(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} * f_{i - 2} * (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;
}

与我也忘了昨天的哪道题一样我们算贡献
即计算当这个最大值为 \(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;
}

这题。。。你想到了就想到了想不到就没办法了
首先对于一个图的 \(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;
}

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

posted @ 2023-07-11 14:34 Steven24 阅读(24) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Steven24

2023.7.11 NOIP模拟赛

赛时记录

补题

公告