codeforce round 946 div3 A-E 题解

最新推荐文章于 2025-05-24 19:20:32 发布
最新推荐文章于 2025-05-24 19:20:32 发布
阅读量480 收藏 5
点赞数 4
文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2401_82728478/article/details/139129020
版权

A Phone Desktop

  早上vp这div3一开始看这题还看错了，其实就是贪心的先放2*2的方格，之后考虑剩余的方格放1*1的方格，计算所需的数量即可

#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<bitset>
#include<string>
#include<cstring> 
#include<iomanip>
#include<iostream>
#include<algorithm>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using ull=unsigned long long ;
#define endl '\n' 
#define int long long 
constexpr int N = 2e5+10,P=131;
constexpr int mod = 998244353;
 
/*inline __int128 read()
{
	__int128 x=0,t=1;char c=getchar();
	while(c<'0'||c>'9'){if(c=='-')t=-1;c=getchar();}
	while(c>='0'&&c<='9'){x=(__int128)(x<<1)+(__int128)(x<<3)+(c^48);c=getchar();}
	return t*x;
}
 
inline void write(__int128 x)
{
	if(x<0){x=-x;putchar('-');}
	if(x>9)write(x/10);
	putchar(x%10+'0');
}*/
 
void solve()
{
	int x,y;
	cin>>x>>y;
	
	int v=y/2;
	int s=v*7;
	if(y%2)s+=11,v++;
	
	if(x<=s)cout<<v<<endl;
	else cout<<v+(x-s)/15+((x-s)%15!=0)<<endl;
}
 
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	
	int t;
	cin>>t;
	
	while(t--)
	solve();
	system("pause");
	return 0;
}

B  Symmetric Encoding

  根据题目意思来，先遍历一遍字符串得到r串，再根据r串先预处理字符对应应当修改的字符并建立相关的映射，再遍历一遍原字符串输出即可

#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<bitset>
#include<string>
#include<cstring> 
#include<iomanip>
#include<iostream>
#include<algorithm>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using ull=unsigned long long ;
#define endl '\n' 
#define int long long 
constexpr int N = 2e5+10,P=131;
constexpr int mod = 998244353;
 
/*inline __int128 read()
{
	__int128 x=0,t=1;char c=getchar();
	while(c<'0'||c>'9'){if(c=='-')t=-1;c=getchar();}
	while(c>='0'&&c<='9'){x=(__int128)(x<<1)+(__int128)(x<<3)+(c^48);c=getchar();}
	return t*x;
}
 
inline void write(__int128 x)
{
	if(x<0){x=-x;putchar('-');}
	if(x>9)write(x/10);
	putchar(x%10+'0');
}*/
 
int n;
string s;
void solve()
{
	cin>>n;
	cin>>s;
	
	string r="";
	set<char>v;
	for(int i=0;i<n;i++)
	v.insert(s[i]);
	
	for(auto val:v)r+=val;
	
	map<char,char>mp;
	for(int i=0;i<r.size();i++)
	mp[r[i]]=r[r.size()-i-1];
	
	for(int i=0;i<n;i++)
	cout<<mp[s[i]];
	cout<<endl;
}
 
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	
	int t;
	cin>>t;
	
	while(t--)
	solve();
	system("pause");
	return 0;
}

C Beautiful Triple Pairs

    这题其实比D题难，这题我是先重后向前遍历一遍数组，每次分别记录{ a[i] ,0, a[i+2] },{0, a[i+1], a[i+2] },{ a[i],a[i+1],0 }之下分别有几个a[i+1],a[i],a[i+2],再记录其下有几种方案，拿总数方案数减去{ a[i] ,a[i+1], a[i+2] }的方案数（因为要保证每对序列要有一个不相同，所以要减去与当前全部相同的方案），一开始我是用map套multiset的方式记录的，但是每次count一遍a[i]的总数是O(n)的时间复杂度。容易超时，这里我们应该用map套map的方式记录，可以使每次获取a[i]的数量降为O(log n)，输出即可；

#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<bitset>
#include<string>
#include<cstring> 
#include<iomanip>
#include<iostream>
#include<algorithm>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using ull=unsigned long long ;
#define endl '\n' 
#define int long long 
constexpr int N = 2e5+10,P=131;
constexpr int mod = 998244353;
 
/*inline __int128 read()
{
	__int128 x=0,t=1;char c=getchar();
	while(c<'0'||c>'9'){if(c=='-')t=-1;c=getchar();}
	while(c>='0'&&c<='9'){x=(__int128)(x<<1)+(__int128)(x<<3)+(c^48);c=getchar();}
	return t*x;
}
 
inline void write(__int128 x)
{
	if(x<0){x=-x;putchar('-');}
	if(x>9)write(x/10);
	putchar(x%10+'0');
}*/
 
struct node
{
	int x,y,z;
	bool operator<(const node&W)const
	{
		if(x==W.x)
		{
			if(y==W.y)
			return z<W.z;
			return y<W.y;
		}
		return x<W.x;
	}
};
 
struct vv
{
	int sum;
	map<int,int>p;
};
 
int n;
int a[N];
void solve()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	cin>>a[i];
	
	int ans=0;
	map<node,vv>v;
	for(int i=n-2;i>=1;i--)
	{
		int n1=a[i],n2=a[i+1],n3=a[i+2];
		if(!v[{0,n2,n3}].p.size())
		v[{0,n2,n3}].sum=1;
		else 
		{
			ans+=v[{0,n2,n3}].sum-v[{0,n2,n3}].p[n1];
			v[{0,n2,n3}].sum++;
		}
		v[{0,n2,n3}].p[n1]++;
		
		if(!v[{n1,0,n3}].p.size())
		v[{n1,0,n3}].sum=1;
		else
		{
			ans+=v[{n1,0,n3}].sum-v[{n1,0,n3}].p[n2];
			v[{n1,0,n3}].sum++;
		}
		v[{n1,0,n3}].p[n2]++;
		
		if(!v[{n1,n2,0}].p.size())
		v[{n1,n2,0}].sum=1;
		else
		{
			ans+=v[{n1,n2,0}].sum-v[{n1,n2,0}].p[n3];
			v[{n1,n2,0}].sum++;
		}
		
		v[{n1,n2,0}].p[n3]++;
	}
	
	cout<<ans<<endl;
}
 
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	
	int t;
	cin>>t;
	
	while(t--)
	solve();
	system("pause");
	return 0;
}

D Ingenuity-2

贪心+构造，列出几种方案可以发现两方每一次选的方向要么与对方相同，要么与对方相反，因此总共可分配方案数n必定是一个偶数，同时上下的方案总数与左右的方案总数必定为偶数，然后我们交替的分配双方，如果发现只分配了一方就不合法，反之输出合法方案即可；

#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<bitset>
#include<string>
#include<cstring> 
#include<iomanip>
#include<iostream>
#include<algorithm>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using ull=unsigned long long ;
#define endl '\n' 
#define int long long 
constexpr int N = 2e5+10,P=131;
constexpr int mod = 998244353;
 
/*inline __int128 read()
{
	__int128 x=0,t=1;char c=getchar();
	while(c<'0'||c>'9'){if(c=='-')t=-1;c=getchar();}
	while(c>='0'&&c<='9'){x=(__int128)(x<<1)+(__int128)(x<<3)+(c^48);c=getchar();}
	return t*x;
}
 
inline void write(__int128 x)
{
	if(x<0){x=-x;putchar('-');}
	if(x>9)write(x/10);
	putchar(x%10+'0');
}*/
 
int n;
char ans[N];
void solve()
{
	cin>>n;
	string s;
	cin>>s;
	
	if(s.size()%2)
	{
		cout<<"NO"<<endl;
		return ;
	}
	else
	{
		map<char,vector<int>>v;
		for(int i=0;i<n;i++)
		v[s[i]].push_back(i);
		
		if((v['N'].size()+v['S'].size())%2||(v['E'].size()+v['W'].size())%2)
		{
			cout<<"NO"<<endl;
			return ;
		}
		
		int i=0;
		int minv=min(v['N'].size(),v['S'].size());
		for(i=0;i<minv;i++)
		{
			if(i&1)
			{
				ans[v['N'][i]]='R';
				ans[v['S'][i]]='R';
			}
			else
			{
				ans[v['N'][i]]='H';
				ans[v['S'][i]]='H';
			}
		}
		
		for(;i<v['N'].size();i++)
		if(i&1)ans[v['N'][i]]='R';
		else ans[v['N'][i]]='H';
		
		for(;i<v['S'].size();i++)
		if(i&1)ans[v['S'][i]]='R';
		else ans[v['S'][i]]='H';
		
		i=0;
		minv=min(v['E'].size(),v['W'].size());
		
		for(i=0;i<minv;i++)
		{
			if(i&1)
			{
				ans[v['E'][i]]='H';
				ans[v['W'][i]]='H';
			}
			else
			{
				ans[v['E'][i]]='R';
				ans[v['W'][i]]='R';
			}
		}
		
		for(;i<v['E'].size();i++)
		if(i&1)
		ans[v['E'][i]]='R';
		else ans[v['E'][i]]='H';
		
		for(;i<v['W'].size();i++)
		if(i&1)
		ans[v['W'][i]]='R';
		else ans[v['W'][i]]='H';
	}
	
	
	char b=ans[0];
	bool flag=false;
	for(int i=0;i<n;i++)
	if(b!=ans[i])flag=true;
	
	if(!flag)cout<<"NO";
	else 
	{
		for(int i=0;i<n;i++)
		cout<<ans[i];
	}
	cout<<endl;
}
 
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	
	int t;
	cin>>t;
	
	while(t--)
	solve();
	system("pause");
	return 0;
}

E Money Buys Happiness

        考虑背包，但是我们发现如果直接以总花费作为背包容量太大，这里我们可以反过来以幸福度作为背包容量，即f_{i,j}表示再第i月幸福度为j情况下的最小花费，最后遍历一遍得到小于（m-1）*x的最大幸福度即可；

#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<bitset>
#include<string>
#include<cstring> 
#include<iomanip>
#include<iostream>
#include<algorithm>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using ull=unsigned long long ;
#define endl '\n' 
#define int long long 
constexpr int N = 2e5+10,P=131;
constexpr int mod = 998244353;

/*inline __int128 read()
{
	__int128 x=0,t=1;char c=getchar();
	while(c<'0'||c>'9'){if(c=='-')t=-1;c=getchar();}
	while(c>='0'&&c<='9'){x=(__int128)(x<<1)+(__int128)(x<<3)+(c^48);c=getchar();}
	return t*x;
}
?
inline void write(__int128 x)
{
	if(x<0){x=-x;putchar('-');}
	if(x>9)write(x/10);
	putchar(x%10+'0');
}*/

int n,m;
int f[60][N];
int v[N],w[N];
void solve()
{
	cin>>n>>m;
	int sz=0;
	for(int i=1;i<=n;i++)
	{
		cin>>w[i]>>v[i];
		sz=max(sz,v[i]);
	}
	
	int tt=sz*50;
	for(int i=0;i<=n;i++)
		for(int j=0;j<=tt;j++)
		f[i][j]=1e18;
	
	f[0][0]=0;
	
	for(int i=1;i<=n;i++)
	{
		for(int j=tt;j>=0;j--)
		{
			f[i][j]=f[i-1][j];
			if(j>=v[i])
			f[i][j]=min(f[i][j],f[i-1][j-v[i]]+w[i]);
		}
		
		for(int j=0;j<=tt;j++)
		if(f[i][j]>(i-1)*m)f[i][j]=1e18;
	}
	
	int ans=0;
	for(int i=0;i<=tt;i++)
		if(f[n][i]<=(n-1)*m)
		ans=max(ans,i);
	
	cout<<ans<<endl;
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	
	int t;
	cin>>t;
	
	while(t--)
	solve();
	system("pause");
	return 0;
}

domain领域
关注
Codeforces Round 946 (Div. 3)
m0_74461146的博客
05-27 655
有两个棋子，一个为r，另一个为h，初始时都在（0，0），有四种操作（N，S，W，E），N向上移动一格，S向下移动一格，E向右移动一格，W向左移动一格。2.当两个同时可以相互抵消时，当操作次数为2时，一定不存在，否则可以将其中一个棋子向一个方向移动一次然后在反方向移动一次，别的操作都分配给另一个棋子，这样在最终两个棋子都在原点。存在一种变换操作，有一个原始字符串s，首先构造辅助字符串r，该字符串由字符串s中所有不同的字母组成，按字母顺序书写，然后将s的每一个字符替换成对应r的对称字符。的网格，不够就再添加。
Codeforces Round 946 (Div. 3)题解
2301_80475191的博客
05-21 1061
题解，水题一个，不过多阐述，就是说，有两种应用，一种是2x2的，另一种是1x1的，问然后有x个1x1的应用，有y个2x2的，问这些应用最少占据多少屏幕（屏幕为5x3），这题显而易见，2x2的应用一个屏幕里最多放两个，那么我们可以先去y/2先去找2x2的应用占据多少个屏幕，然后留下来7*y/2个1x1应用的空间，然后判断y是奇数还是偶数，如果是奇数屏幕+1.留下空间，再+11，最后再去与x比较，>x说明，就是前面的那些屏幕，少了，就去x-留下空间数量再除以15，并且判断余数，是否需要再去+1。
Codeforces Round #946 (Div. 3)（A-E） python
wyzkeyy的博客
05-21 614
哈希表存储当前幸福的所需花费的最小值，遍历每一月，若钱数符合则更新哈希表取最小花费，最后找能得到的最大幸福度。注意，若以（0， 0）为终点时，要手动使其完成一次来回的操作，防止出现未行动的可能。将最终x，y除二，即可得到他们的终点，然后模拟其中一者走到终点的过程即可。观察数据，发现c很大但m和h很小，考虑以当前的幸福度为容量进行dp，一个屏幕最多能装两个大方格，先放完大的，剩下的空隙放小的，不够再补。哈希表存一下不同的分别为第1，2，3位时，不同取值对应的剩下元素值。
Codeforces Round 1023 Div2 A-C题解
W_Sherlock_Henry的博客
05-06 770
这场其实D思路也很简单，就是一道树的直径的板子题，但是很麻烦没写出来，主要C本身也是比较麻烦的模拟题，所以这个D就没想做，这场模拟场，主要就是写起来会麻烦不少。
Codeforces Round 946 (Div. 3)A-G
2301_80210089的博客
05-21 1000
， 可以想到这种情况只有两种， 也就是每种操作出现一次以及某一轴上的正负操作都为1，另一轴上没有， 所以可以特判。首先可见三元组的个数并不多， 所以我们可以考虑记录下第一个，第二个相等的个数s1，第一个，第三个相等的个数s2， 第二个，第三个相等的个数s3， 然后在记录全部相等的个数s，那么[x, y, z]能够给答案做出的贡献为s1 + s2 + s3 - 3 * s， 考虑到某一对答案交换顺序还是这一对，所以我们可以从左向右维护s， s1， s2， s3， 或者全部相加除2， 这里我是从左向右维护。
codeforce Round 935 div3 个人题解（A~F）
Lazy_ChessPlayer的博客
03-19 1400
每个测试1秒：每个测试256兆字节：标准输入：标准输出组委会计划在游览结束后带领奥林匹克运动会的参赛选手进行徒步旅行。目前，正在计算需要搭帐篷的数量。已知每顶帐篷最多可容纳3人。告诉我们至少需要多少顶帐篷，以满足所有参赛者的愿望。如果无法满足，则输出-1。
codeforce round 753 div3 题解报告
徒手拆机甲的博客
11-17 499
codeforce round 753 div3 题解报告 在vp比赛的时候只过了5题，后三题跨度还是挺大，不过也有前五题写的慢的愿意在里面，没有太多时间看后面的题。 A. Linear Keyboard 给你一个键盘的顺序，让你模拟打某个单词需要的步数，稍微对应建立映射即可 #include<bits/stdc++.h> using namespace std; int t,n; map<char,int>mp; int main() { string s1,s2; scanf
codeforce Round 934 div2 个人题解（A~C）
Lazy_ChessPlayer的博客
03-17 1003
1秒256兆标准输入标准输出有n个岛屿，编号为12n。最初，每对岛屿都由一座桥连接。因此，一共有2nn−1​座桥。Everule 住在岛屿1上，喜欢利用桥梁访问其他岛屿。Dominater 有能力摧毁最多k座桥梁，以尽量减少 Everule 可以使用(可能是多座)桥梁到达的岛屿数量。如果 Dominater 以最佳方式摧毁桥梁，求 Everule 可以访问的岛屿(包括岛屿1)的最少数量。
【寒假复健Day5】Codeforces Round 1003 (Div. 4) - 题解
multiple_issue的博客
02-10 992
Codeforces Round 1003 (Div. 4) - 题解
Codeforces Round 946 (Div. 3)Codeforces Round 946 (Div. 3) 动态规划dp 01背包
JK01WYX的博客
05-22 536
而总钱数我们是可以根据天数 j * 工资 x 来求出 ， 那么就足以判断在这个状态下是否有足够钱可以购买这个商品了。那么 i - h[ j ] 就是买这个商品 j 前的总价值 ，dp[ i - h[ j ] ]就是。一共 m 天，每天都有一个商品，价格 c[ i ]，价值 h[ i ]。其实我们可以问题分离，先把所有最优状态求出来，然后检查是否可行即可。dp[ i ] 表示 购买价值到 i 时，消耗的最少钱数。本题就是在01背包上限制了个我们有的钱数。从第二天开始每天加 x 块钱。问最后最多买多少h。
【C】【杰理】printf无法打印浮点数
weixin_46125941的博客
05-24 762
如果确认printf的格式化字符串正确（包含%f占位符），且其他文本（如temp0 =）已输出但数值部分显示为0.00000000NaNINF0.0M_Gint01e-6%f0.000000±INFNaNM_G=9.8int32_t\n9.80665frawlsb_1g通过以上步骤，可逐步定位并解决浮点数输出异常的问题。
C++：关联式容器map容器，multimap容器
2301_80311224的博客
05-22 565
map容器存储的都是pair类型的键值对元素，pair<const K,T>,K表示键，T表示数据类型，其各个元素的键必须是唯一的，会按照元素键的大小，默认升序排序。map容器的底层是红黑树。之前提到的四种容器都是序列式容器，本贴将讲述关联式容器中的map容器。而multimap容器存储元素的键可重。multimap：有序键可重。
C++ 的 out_ptr 和 inout_ptr
oRbIt 的专栏
05-23 506
C++ 智能指针在与需要 T** 或 T&* 参数的 C 风格函数交互时，传统解决方案如代理类虽能缓解问题，但存在各种问题。C++ 23 引入了 out_ptr_t 和 inout_ptr_t 智能指针适配器，通过 std::out_ptr() 和 std::inout_ptr() 简化使用，实现了与 C 风格 API 的安全交互。
简单用c++的类实现的string
2503_91454631的博客
05-22 369
【代码】简单用c++的类实现的string。
《算法笔记》11.7小节——动态规划专题-＞背包问题 问题 C: 货币系统
2401_88085478的博客
05-20 278
举例来说, 使用一个货币系统 {1,2,5,10,...}产生 18单位面值的一些可能的方法是:18x1, 9x2, 8x2+2x1, 3x5+2+1,等等其它。传统地，一个货币系统是由1,5,10,20 或 25,50, 和 100的单位面值组成的。母牛想知道有多少种不同的方法来用货币系统中的货币来构造一个确定的数值。写一个程序来计算有多少种方法用给定的货币系统来构造一定数量的面值。母牛们不但创建了他们自己的政府而且选择了建立了自己的货币系统。(1<= N<=10,000)输入包含多组测试数据。
怎么开发一个网络协议模块（C语言框架）之(四) 信号量初始化
最新发布
dlz0836的博客
05-24 41
摘要：该代码片段展示了VRRP模块中信号量的创建与使用。原始代码通过注释将二进制信号量(BSem)改为互斥信号量(MSem)，原因在于MSem更适合互斥访问场景，且支持删除安全特性。信号量用于保护全局共享资源(如gVrrpInstance)的多线程访问，创建失败时会打印错误并跳转清理。建议统一封装加锁/解锁宏，简化开发并确保线程安全。结论表明MSem比BSem更安全可控，适合协议栈开发需求。
C++：虚函数与纯虚函数
2401_86107325的博客
05-24 493
本文介绍了C++中虚函数与多态继承的实现机制。虚函数通过在基类和派生类中声明virtual关键字实现动态绑定，使程序根据对象类型选择相应方法版本。虚函数通过虚函数表实现运行时动态联编，与静态联编的非虚函数形成对比。文章还讨论了纯虚函数与抽象类的概念，指出纯虚函数（如=0声明）强制派生类实现特定接口，抽象类不能实例化。此外，强调了继承关系中应将析构函数设为虚函数以确保正确析构，并提醒派生类重定义虚函数时可能隐藏基类同名方法。这些机制共同支撑了C++面向对象的多态特性。
C++题解(33)2025年顺德区中小学生程序设计展示活动（初中组C++）U560876 美丽数（一）和 U560878 美丽数（二）题解
2301_78151773的博客
05-24 79
小明很喜欢3和5这两个数字，他将能被3或5整除的数叫做美丽数。现在给你一个整数n，你能告诉小明第n个美丽数是多少吗？小明很喜欢某些数字，他将能被这些数同时整除的数叫做美丽数。，如有表述不当，可在评论区提出，作者将在3-10日内回复并修正。【题干与《美丽数（一）》基本一致，仅规“美丽数”的定义不同】第2行有m个整数，分别以空格隔开，这些数字范围在[1,9]；输入有多行，每行只有一个整数${n_i}$。输出多行，每行代表第${n_i}$个美丽数。输出多行，每行代表第ni​个美丽数。U560876 美丽数（一）
Lockout-Bot: Codeforce Discord机器人挑战赛
3. **使用场景**： - Lockout-Bot可用于组织线上编程比赛，从而在朋友或者社区之间进行编程技能的较量。 - 通过这种机器人，Codeforce用户可以在Discord上模拟实际的编程竞赛环境，不仅可以提升个人技能，还能够...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值