CF1835 题解

CF1835 题解

A

考虑到 a,b,c>3 的最多只有 5 个，可以直接循环枚举 A 。首先将 B 取到最小值，然后判断 C 是否达到了最小值，如果没有就将 B 和 C 同时补齐。此时特判如果 C 大于上限（就是 ≥10c ），就不对答案贡献。不然在 A 一定的状态下，可以将 B,C 同加，作出的贡献就是 min {maxb − b,maxc − c} 。如果 k 不够了就补齐输出即可。

按上述过程模拟，注意细节。

#include<bits/stdc++.h>
using namespace std;
int a,b,c,A,B,C,maxc,maxb,maxa;
long long k;
inline int pow(int x,int tms)
{
	int ret = 1;
	for(int i = 1;i <= tms;i++) ret *= x;
	return ret;
}
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		cin>>a>>b>>c>>k;
		maxa = pow(10,a); maxb = pow(10,b); maxc = pow(10,c);
		if(max(a,b) < c - 1){puts("-1");continue;}
		for(A = maxa / 10;A < maxa;A++)
		{
			B = maxb / 10;
			C = A + B;
			if(C < maxc / 10){B += maxc / 10 - C;C = maxc / 10;}
			if(C >= maxc) break;
			if(B >= maxb) continue;
			if(k > min(maxc - C,maxb - B)) k -= min(maxc - C,maxb - B);
			else
			{
				B += k - 1; C += k - 1;
				cout<<A<<" + "<<B<<" = "<<C<<endl;
				k = 0;
				break;
			}
		}
		if(k) puts("-1");
	}
	return 0;
}

B

如果我们确定了最后一个人选的位置 x ，就可以用一个函数 O(log⁡n) 计算出可以中奖的号码对应的区间。方法是二分出左右两边分别到 x 这一段包含 k 个点（含自身）的个数。那么对于左边，中奖号码能取的区间就是 x 和左端点的中点右取整，右边同理。

考虑我们不能枚举每一个 x 的位置，哪些位置才是有用的。结论是，每个被别人选过的点 −2,−1,0,+1,+2 。考虑讨论一下两个相邻的别人选的位置，中奖号码是在两个左边，中间，还是两个右边。可以发现不管是哪里靠近两端都是不劣的，+2 是因为如果中奖号码取到某个特殊的位置，最后一个人取 +1 时可能和右边的人并列，导致输掉。所以可以 +2 来规避这个问题。

从左向右询问 x 可以用双指针完成。时间复杂度 O(nlog⁡n) 。瓶颈在于排序。

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
typedef long long ll;
ll n,m,k,pm = 1,px = 1;
ll a[N];
inline ll calc(ll x)
{
	while(pm <= n && a[pm] < x) ++pm;
	while(px <= n && a[px] <= x) ++px;
	ll l,r;
	l = ((px - k > 0) ? x - (x - a[px - k] + 1) / 2 + 1: 0);
	r = ((pm + k - 1 <= n) ? x + (a[pm + k - 1] - x + 1) / 2 - 1 : m);
	return max(0ll,r - l + 1);
}
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	cin>>n>>m>>k;
	for(int i = 1;i <= n;i++) cin>>a[i];
	a[n + 1] = m + 1;
	sort(a + 1,a + n + 1);
	ll ans = calc(0),mxpos = 0;
	for(ll i = 1,nl,nr;i <= n;i++)
	{
		if(i == 1) nl = max(0ll,a[i] - 2);
		else nl = max(a[i] - 2,a[i - 1] + 3);
		nr = min(m,a[i] + 2);
		for(ll j = nl;j <= nr;j++)
		{
			ll now = calc(j);
			if(now > ans) ans = now,mxpos = j;
		}
	}
	cout<<ans<<" "<<mxpos;
	return 0;
}

C

我们发现数据十分特殊，异或前缀和一下变成是否有 4 个数 a,b,c,d ，满足 a xor b=c xor d 。我们将数拆分成二进制前 k 位和后 k 位。前 k 位有至多 2k 种数字，我们有 2k+1+1 个前缀（包括 0）。如果我们对于前缀 i ，找到一个前缀 j ，两个的前 2k 位相等，那么 [i,j] 的异或和就只有后 k 位。我们先将前面的可能填满，后面还有 2k+1 个前缀，对于后 k 位就有 2k+1 个取值。因为后 k 位只有 2k 个取值，所以一定能匹配到一个取值，使得后 k 位异或为 0 ，这样就找到了答案。

所以并不存在 −1 的情况，异或和 hash 一下就可以了。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 4e5 + 5;
int n,m,jdg = 0;
ll a[N],pre[N],vis[N];
map <ll,pair<int,int> > p;
inline void calc(int l,int r)
{
	if(p.find(a[l - 1] ^ a[r]) == p.end())
	{
		p[a[l - 1] ^ a[r]] = make_pair(l,r);
		return;
	}
	pair <int,int> res = p[a[l - 1] ^ a[r]];
	if(res.second < l) cout<<res.first<<" "<<res.second<<" "<<l<<" "<<r<<endl;
	else if(res.first <= l && l <= res.second) cout<<res.first<<" "<<l - 1<<" "<<res.second + 1<<" "<<r<<endl;
	else if(res.first > l) cout<<l<<" "<<res.first - 1<<" "<<res.second + 1<<" "<<r<<endl;
	jdg = 1;
}
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		p.clear();
		cin>>n; jdg = 0;
		m = (1 << (n + 1));
		for(int i = 1;i <= m;i++) cin>>a[i];
		for(int i = 2;i <= m;i++) a[i] ^= a[i - 1];
		for(int i = 0;i <= m / 2;i++) vis[i] = -1;
		vis[0] = 0;
		for(int i = 1;i <= m;i++)
		{
			if(vis[(a[i] >> n)] != -1) calc(vis[(a[i] >> n)] + 1,i);
			vis[(a[i] >> n)] = i;
			if(jdg) break;
		}
	}
	return 0;
}

D

首先缩点，将原图缩成一些 SCC 。考虑如果想用每个 SCC 内部的环绕出一个距离的话，每个环最多绕 n 次，最多有 n 个环，环长最多为 n 。所以当 k≥n3 时，如果有解，一定能绕出来。 x,y 能互相到达，一定在一个 SCC 内。

由裴蜀定理可得，一些环长能凑出的长度是 gcd 的倍数。想要知道每一个环的信息，考虑构造生成树，每条非树边都能贡献一个最小环。由于是在每个 SCC 内分别 dfs ，所以没有横叉边，只有返祖边，所以环长等于 |depu−depv−1| 。

考虑满足条件的 x,y ，满足 depu−depy≡depv−depi≡k (modd) 。

所以 k≡0 (modd) 或者 k≡d2(modd) ，第二种情况 d 为偶数。

开桶分别计算即可。

#include<bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct Edge{
	int v,next;
}e[N * 2];
typedef long long ll;
ll k;
int d,n,m,head[N],dfn[N],vis[N],cnt = 0,low[N],belong[N],tot = 0,top = 0,s[N],dep[N],pot[N];
vector <int> pts[N];
inline void add(int x,int y)
{
	++tot;
	e[tot].v = y;
	e[tot].next = head[x];
	head[x] = tot;
}
inline void tarjan(int x)
{
	dfn[x] = low[x] = ++tot;
	vis[x] = 1;
	s[++top] = x;
	for(int i = head[x];i;i = e[i].next)
	{
		int to = e[i].v;
		if(!dfn[to])
		{
			tarjan(to);
			low[x] = min(low[x],low[to]);
		}
		else if(vis[to])
			low[x] = min(low[x],dfn[to]);
	}
	if(dfn[x] == low[x])
	{
		++cnt;
		while(s[top + 1] != x)
		{
			belong[s[top]] = cnt;
			pts[cnt].push_back(s[top]);
			vis[s[top]] = 0;
			--top;
		}
	}
}
inline void dfs(int x)
{
	vis[x] = 1;
	for(int i = head[x];i;i = e[i].next)
	{
		int to = e[i].v;
		if(belong[to] != belong[x]) continue;
		if(!vis[to]) 
		{
			dep[to] = dep[x] + 1;
			dfs(to);
		} 
		else
			d = __gcd(d,abs(dep[to] - dep[x] - 1));
	}
}
int main()
{
	cin>>n>>m>>k;
	for(int i = 1,x,y;i <= m;i++)
	{
		cin>>x>>y;
		add(x,y);
	}
	tot = 0;
	for(int i = 1;i <= n;i++) if(!dfn[i]) tarjan(i);
	memset(vis,0,sizeof(vis));
	ll ans = 0;
	for(int i = 1;i <= n;i++)
	{
		if(vis[i]) continue;
		dep[i] = 1;
		d = 0;
		dfs(i);
		if(!d) continue;
		int max_dep = 0;
		for(auto in : pts[belong[i]])
		{
			pot[dep[in]]++;
			max_dep = max(max_dep,dep[in]);
		}
		if(k % d == 0)
		{
			for(int j = 1;j <= max_dep;j++) 
			{
				ans += 1ll * pot[j] * (pot[j] + 1) / 2;
				if(j > d)
				{
					ans += 1ll * pot[j] * pot[j - d];
					pot[j] += pot[j - d];
				}
			}
		}
		else if((k % d) * 2 == d)
		{
			for(int j = d / 2 + 1;j <= max_dep;j++)
			{
				ans += 1ll * pot[j] * pot[j - d / 2];
				pot[j] += pot[j - d];
			}
		}
		fill(pot,pot + max_dep + 1,0);
	}
	cout<<ans;
	return 0;
}

E

学习了洛谷上 Solystic 神犇的做法。

考虑当前策略只和几个信息有关：是否知道 backspace ，是否知道下一个敲的字母，以及当前敲的是否正确。

  • 如果不知道 backspace：

    • 如果知道下一个敲的字母，直接敲即可。

    • 如果不知道，就随便乱按，按错了就找出 backspace 然后删掉即可。

  • 如果知道 backspace ：

    • 如果知道下一个敲的字母，直接敲。

    • 如果不知道，就随便乱按，按错了就删掉。

我们发现只有遇到新字符是我们才可能乱按。

设 fi,j,1/2/3/4 为已经输入了前 i 个字符，有 j 个字符知道键位，但是没有输入的期望步数。

1：不知道 backspace ，当前输入完全正确。

2：不知道 backspace ，当前输入不正确。

3：知道 backspace ，不确定是否知道下一个字符。

4：知道 backspace ，不知道下一个字符。

转移有 3+4+1+2=10 种转移，详见洛谷大佬博客。

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5,M = 1005,MOD = 1e9 + 7;
int n,m,a[N],l[M],cnt = 0,vis[M];
typedef long long ll;
ll inv[N],f[M][M][5];
inline void add(ll &x,ll y){x = (x + y) % MOD;}
int main()
{
	cin>>n>>m;
	memset(l,0,sizeof(l));
	for(int i = 1;i <= n;i++) 
	{
		cin>>a[i];
		if(!vis[a[i]]) vis[a[i]] = 1,l[cnt] = i - 1,++cnt;
	}
	l[cnt] = n;
	memset(f,0,sizeof(f));
	inv[1] = 1;
	for(int i = 2;i <= M - 1;i++) inv[i] = (MOD - MOD / i) * inv[MOD % i] % MOD;
	for(int i = cnt - 1;i >= 0;i--)
		for(int j = m - i;j >= 0;j--)
		{
			if(m - i - j > 0)
			{
				add(f[i][j][4],inv[m - i - j] * ((f[i + 1][j][3] + l[i + 1] - l[i]) % MOD) % MOD);
				add(f[i][j][4],(m - i - j - 1) * inv[m - i - j] % MOD * (f[i][j + 1][4] + 2) % MOD);
			}
			
			if(j > 0) add(f[i][j][3],j * inv[m - i] % MOD * ((f[i + 1][j - 1][3] + l[i + 1] - l[i]) % MOD) % MOD);
			add(f[i][j][3],(m - i - j) * inv[m - i] % MOD * f[i][j][4] % MOD);
			
			add(f[i][j][2],(m - i - j) * inv[m - i - j + 1] % MOD * (f[i][j + 1][2] + 2) % MOD);
			if(j > 0) add(f[i][j][2],inv[m - i - j + 1] * (j - 1) % MOD * inv[m - i - 1] % MOD * ((f[i + 1][j - 1][3] + l[i + 1] - l[i]) % MOD) % MOD);
			add(f[i][j][2],inv[m - i - j + 1] * (m - i - j) % MOD * inv[m - i - 1] % MOD * f[i][j][4] % MOD);
			
			if(j == 0)
			{
				add(f[i][0][1],inv[m - i + 1] * ((f[i + 1][0][1] + l[i + 1] - l[i]) % MOD) % MOD);
				add(f[i][0][1],inv[m - i + 1] * (f[i][0][3] + 1 + (i != 0)) % MOD);
				add(f[i][0][1],(m - i - 1) * inv[m - i + 1] % MOD * (f[i][1][2] + 2) % MOD);
			}
		}
	cout<<f[0][0][1];
	return 0;
}

F

咕。

posted @   The_Last_Candy  阅读(9)  评论(0)  编辑  收藏  举报
相关博文：
·  CF1827 题解
·  CF1710 题解
·  【题解】CF1835 合集
·  CF1835A 题解
·  【题解】CF1854 合集
阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列01：轻松3步本地部署deepseek，普通电脑可用
· 按钮权限的设计及实现
· 25岁的心里话
点击右上角即可分享
微信分享提示
AI IDE Trae