Codeforces Round #734 (Div. 3) (A-E题详解)

最新推荐文章于 2022-03-05 21:52:52 发布
最新推荐文章于 2022-03-05 21:52:52 发布
阅读量374 收藏 1
点赞数 2
分类专栏： 补题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52688175/article/details/119082872
版权

A. Polycarp and Coins

题意：t组测试数据，每组测试数据包含一个n，问你把n元钱平均分成1块钱和两块钱，输出一块钱和两块钱的个数

思路：先给两块钱，剩下的钱就是一块钱的，因为除法可能不平衡，在把差值抹掉平衡就好

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<iostream>
#include<algorithm>
const int maxn=10000;
using namespace std;
int main(){
	int n,x,ans1,ans2;
	scanf("%d",&n);
	while(n--){
		scanf("%d",&x);
		ans2=x/3*2;
		ans1=x-ans2;
		ans2/=2;
		while(ans1-ans2>=2){
			ans1-=2;
			ans2++;
		}
		printf("%d %d\n",ans1,ans2);
	} 
	return 0;

}

B1. Wonderful Coloring - 1

题意：t组测试数据，每组测试数据包含一个字符串n，你有两种颜色的染料，你需要给每个字符涂色，每种颜色的字母唯一，也就是说，每种字母只能涂两次，第三次出现不涂色，问你平均分配每个颜色有几个字母

思路：记录每个字母出现的次数，每次出现，字母总数+1，第二次以后出现不加字母总数，将字母总数除2输出即可

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;
int b[1000];
int main(){
	string a;
	int n,ans=0;
	scanf("%d",&n);
	while(n--){
		cin>>a;
		ans=0;
		memset(b,0,sizeof(b));
		if(a.size()<2){
			printf("0\n");
			continue;
		}
		for(int i=0;i<a.size();i++){
			b[a[i]]++;
			if(b[a[i]]<=2){
				ans++;
			}
		}
		printf("%d\n",ans/2);
	}
	return 0;
}

B2. Wonderful Coloring - 2

B1的进化版

题意：给你t组测试数据，每组测试数据包含n（数组长度）k（颜料总数）
数组每个元素包含一个数字，将数字平均分给每个颜料（同样一种颜料中每个数字只能有一个，必须保证每种颜色的数字个数相同），让你染色后将这个数组的颜色输出，不染色的数字输出0，有多种答案，输出其中一种即可

Example
input
6
10 3
3 1 1 1 1 10 3 10 10 2
4 4
1 1 1 1
1 1
1
13 1
3 1 4 1 5 9 2 6 5 3 5 8 9
13 2
3 1 4 1 5 9 2 6 5 3 5 8 9
13 3
3 1 4 1 5 9 2 6 5 3 5 8 9

output

1 1 0 2 3 2 2 1 3 3
4 2 1 3
1
0 0 1 1 0 1 1 1 0 1 1 1 0
2 1 2 2 1 1 1 1 2 1 0 2 2
1 1 3 2 1 3 3 1 2 2 3 2 0

思路：我们用vector数组记录每种数字出现的位置，出现次数大于等于k的数字标记并将其出现位置染色，那么我们后面只用处理出现次数小于k的数字了，将这些数字用结构体记录它是什么数字，出现在什么位置，按数字大小排序，因为剩下的这些数字个数总数不一定是k的倍数，我们先将数字个数 总数除k再乘k，保证能分配给每个颜色的数字个数相同，从小到大赋值颜色1到k即可

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define M(a,b) make_pair(a,b)
const int maxn=2e5+50;
vector<pair<int,int> >q;
vector<int>a[maxn];
int t,n,k,x,ans[maxn],vis[maxn];
int main()
{

	scanf("%d",&t);
	while(t--){
		memset(vis,0,sizeof(vis));
		memset(ans,0,sizeof(ans));
		for(int i=1;i<=n;i++){
			a[i].clear();
		}
		q.clear();
		scanf("%d %d",&n,&k);
		for(int i=1;i<=n;i++){
			scanf("%d",&x);
			a[x].push_back(i);
		}
		for(int i=1;i<=n;i++){
			if(a[i].size()>=k){
				for(int j=0;j<a[i].size();j++){
					ans[a[i][j]]=j+1;
				} 
				vis[i]=1;
			}
		}
		for(int i=1;i<=n;i++){
			if(vis[i]==0){
				for(int j=0;j<a[i].size();j++){
					q.push_back(M(i,a[i][j]));
				}				
			}
		}
		sort(q.begin(),q.end());
		int v=1;
		int sum=q.size();
		sum/=k;
		sum*=k;
		for(int i=0;i<sum;i++){
			ans[q[i].second]=v++;
			if(v>k){
				v=1;
			}
		}
		for(int i=1;i<=n;i++){
			if(ans[i]>k){
				printf("0 ");
			}else printf("%d ",ans[i]);
		}
		printf("\n");
	}
}

C. Interesting Story

题意：给你t组测试数据，每组测试数据给你n 个只包含 a、b、c、d、ea、b、c、d、e 的字符串，让你从中选择若干个，使得某一个单一字符的出现次数大于其余四个总和，问最多可以选多少个字符串。

思路：贪心，我们遍历a到e，以每个元素为主元素，记录每个字符串的总元素与其他元素和的差值，sort排序，从最大的开始加，直到加到总差值<=0

看着代码量很多，其实以每个元素为主函数的函数基本都是相同的，真正的代码量其实不多

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 2e5 + 50;
typedef long long ll;
int a[maxn], b[maxn], c[maxn], d[maxn], e[maxn];
int n,ans,t;
string s;
int aa(){
    vector<ll> ans;
    for(int i = 0;i < n;i++){
        ll sum = a[i];
        ll now = b[i] + c[i] + d[i] + e[i];
        ans.push_back(sum - now);
    }
    sort(ans.rbegin(), ans.rend());
    ll k = 0;
    int cnt = 0;
    for(int i = 0;i < n;i++){
        if(k + ans[i] > 0) {
            cnt++;
            k += ans[i];
        }
        else break;
    }
    return cnt;
}
int bb(){
    vector<ll> ans;
    for(int i = 0;i < n;i++){
        ll sum = b[i];
        ll now = a[i] + c[i] + d[i] + e[i];
        ans.push_back(sum - now);
    }
    sort(ans.rbegin(), ans.rend());
    ll k = 0;
    int cnt = 0;
    for(int i = 0;i < n;i++){
        if(k + ans[i] > 0) {
            cnt++;
            k += ans[i];
        }
        else break;
    }
    return cnt;
}
int cc(){
    vector<ll> ans;
    for(int i = 0;i < n;i++){
        ll sum = c[i];
        ll now = a[i] + b[i] + d[i] + e[i];
        ans.push_back(sum - now);
    }
    sort(ans.rbegin(), ans.rend());
    ll k = 0;
    int cnt = 0;
    for(int i = 0;i < n;i++){
        if(k + ans[i] > 0) {
            cnt++;
            k += ans[i];
        }
        else break;
    }
    return cnt;
}
int dd(){
    vector<ll> ans;
    for(int i = 0;i < n;i++){
        ll sum = d[i];
        ll now = a[i] + b[i] + c[i] + e[i];
        ans.push_back(sum - now);
    }
    sort(ans.rbegin(), ans.rend());
    ll k = 0;
    int cnt = 0;
    for(int i = 0;i < n;i++){
        if(k + ans[i] > 0) {
            cnt++;
            k += ans[i];
        }
        else break;
    }
    return cnt;
}
int ee(){
    vector<ll> ans;
    for(int i = 0;i < n;i++){
        ll sum = e[i];
        ll now = a[i] + b[i] + c[i] + d[i];
        ans.push_back(sum - now);
    }
    sort(ans.rbegin(), ans.rend());
    ll k = 0;
    int cnt = 0;
    for(int i = 0;i < n;i++){
        if(k + ans[i] > 0) {
            cnt++;
            k += ans[i];
        }
        else break;
    }
    return cnt;
}
int main()
{
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        for(int i = 0;i <= n;i++){
        	a[i]=b[i]=c[i]=d[i]=e[i]=0;
		}
        for(int i = 0;i < n;i++){
            cin >> s;
            for(int j = 0; j < s.size();j++){
                if(s[j] == 'a') a[i]++;
                else if(s[j] == 'b') b[i]++;
                else if(s[j] == 'c') c[i]++;
                else if(s[j] == 'd') d[i]++;
                else if(s[j] == 'e') e[i]++;
            }
        }
        ans = 0;
        ans = max(ans, aa());
        ans = max(ans, bb());
        ans = max(ans, cc());
        ans = max(ans, dd());
        ans = max(ans, ee());
        printf("%d\n",ans);
    }
    return 0;
}

D1. Domino (easy version)

题意：t组测试数据，每组给你一个n * m的表（n*m一定为偶数），你可以用1 * 2或者2 * 1的多米诺骨牌填充它，问你可不可以用填满它且只用k个1 * 2的多米诺骨牌

思路：我们一定会用 n * m / 2个骨牌填满这个表， n * m一定为偶数，那么n或者m最多有一个奇数，我们先看n，m都是偶数的情况下，在一个2 * 2的表中我们发现不管是横着填充还是竖着填充都可以，也就是说，此时只要k是偶数就一定满足（2 * 2的必须用成对的骨牌填充），n为奇数的情况下，我们最下面多了一行，必须填m/2个横的骨牌，m为奇数的情况下，最右边多一列，必须填n / 2个竖的骨牌 （一个奇数原则）我编的原则 把多出来的补上，剩下的就随便填充了，我们保证前面能填满就行

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<iostream>
#include<algorithm>
#include<utility>
using namespace std;
typedef long long ll;
#define M(a,b) make_pair(a,b)
const int maxn=2e5+50;
vector<pair<int,int> >q;
vector<int>a[maxn];
int t,n,k,x,ans[maxn],vis[maxn];
int main()
{
	int n,m,t;
	scanf("%d",&t);
	while(t--){
		scanf("%d %d %d",&n,&m,&k);
		int sum=n*m/2;
		if(n%2==1){
			sum-=m/2;
			k-=m/2;
		}
		if(m%2==1){
			sum-=n/2;
		}
		if(k<0||k%2==1||k>sum){
			printf("NO\n");
		}else printf("YES\n");
	}
	return 0;
}

D2. Domino (hard version)

D1 加强版

题意：原则同上，但要你用小写英文字母（随便什么字母）输出那个表，保证相邻的字母不一样就行

思路：大体不变，减行减列时特殊处理，其他行列我们先把k个横着的填出来，剩下的全填竖着的即可，主要是相邻字母不一样，我们可以根据行列规律填就是了

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 2e3 + 10;
int n,k,n1,m1,t,sum,m;
char ans[205][205];
int main()
{
	cin>>t;
	while(t--){
		cin>>n>>m>>k;
		n1=n,m1=m;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				ans[i][j]='0';
			}
		}
		sum=n*m/2;
		if(n%2==1){
			int count1=0;
			for(int i=1;i<=m;i+=2){
				count1++;
				if(count1%2==1){
					ans[n][i]=ans[n][i+1]='x';
				}else ans[n][i]=ans[n][i+1]='y';
			}
			n--;
			k-=m/2;
			sum-=m/2;
		}
		if(m%2==1){
			int count1=0;
			for(int i=1;i<=n;i+=2){
				count1++;
				if(count1%2==1){
					ans[i][m]=ans[i+1][m]='i';
				}else ans[i][m]=ans[i+1][m]='o';
			}
			m--;
			sum-=n/2;
		}
		if(k<0||k%2==1||k>sum){
			printf("NO\n");
			continue;
		}
		int count1=0;
		for(int j=1;j<=m;j+=2){
			count1++;
			for(int i=1;i<=n;i++){
				if(k==0){
					break;
				}
				if((count1+j)%2==1){
					ans[i][j]=ans[i][j+1]='a';
				}else ans[i][j]=ans[i][j+1]='b';
				k--;
				count1++;
				if(k==0){
					break;
				} 
			}
			if(k==0){
				break;
			}
		}
		count1=0;
		for(int i=1;i<=n;i+=2){
			count1++;
			for(int j=1;j<=m;j++){
				if(ans[i][j]=='0'){
					if((j+count1)%2==1){
						ans[i][j]=ans[i+1][j]='c';
					}else ans[i][j]=ans[i+1][j]='d'; 
				}
			}
		}
		printf("YES\n");
		for(int i=1;i<=n1;i++){
			for(int j=1;j<=m1;j++){
				printf("%c",ans[i][j]);
			}
			printf("\n");
		}
	}
    return 0;
}

E. Fixed Points

题意：t组测试数据，每组测试数据包含一个长度为n的数组和一个常数k
对数组你有两种操作
1 对当前数字什么也不做
2 删掉当前数字，后面的数字全都往前移一位
定义一个数组b1，b2 … bm为原数组经过ans次操作2后的数组，其中bi=i 的元素有>=k个，问你ans最小是几

思路：dp题，我们定义一个二维数组dp[ i ] [ j ] 表示一共经过了i个元素，经行了j次操作2，那么递推公式就出来了

不删除a [ i ] ，那么 dp [ i ] [ j ] = dp [ i -1 ] [ j-1 ]
删除a [ i ] ， 那么dp [ i ] [ j ] =dp [ i -1 ] [ j ] + (a[ i ] == i - j)

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 2e3 + 10;
int n,k,a[N],t,f[N][N];
signed main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d %d",&n,&k);
        memset(f , 0 , sizeof(int) * n * n);
        for(int i = 1 ; i <= n ; i ++){
        	scanf("%d",&a[i]);
		}
        for(int i = 1 ; i <= n ; i ++)
        {
            for(int j = 0 ; j <= i ; j ++)
            {
                if(!j) f[i][j] = f[i - 1][j] + (a[i] == i - j);
                else f[i][j] = max(f[i - 1][j - 1], f[i - 1][j] + (a[i] == i - j));
            }
        }
        bool flag = 0;
        for(int j = 0 ; j <= n ; j ++) if(f[n][j] >= k)
        {
            flag = 1;
            printf("%d\n",j);
            break ;
        }
        if(!flag) printf("-1\n");
    }
    return 0;
}
是小怪兽啊
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Codeforces Round #734 (Div. 3)
qq_54484765的博客
07-24 157
Codeforces Round #734 (Div. 3) A. Polycarp and Coins 题目大意： 有一个人买东西付钱，但他只有一元的钱和二元的钱， 现在他要付 n 元， 他使用一元钱的数量和二元钱数量的差值要最小， 问他付 n元使用了多少一元钱和二元钱？ 解题思路： 直接将ans=n/3，便可分三种情况输出： 如果n%3==0,则说明刚好能用相同数量的一元钱和两元钱组成，直接输入两个ans即可。 如果n%3==1,说明还需要出一块钱，则输出ans+1和ans即可。 如果n%3==2
Codeforces Round #734 (Div. 3)A,B1题解(思路简单，代码好懂)
qq_51816306的博客
07-24 246
Codeforces Round #734 (Div. 3) Codeforces Round #734 (Div. 3)A,B1题解(思路简单，代码好懂) 题目链接： A. Polycarp and Coins B1. Wonderful Coloring - 1 A. Polycarp and Coins 题目大意：买一个价格为n的商品，只用面值为1和2的硬币，输出面值为1和面值为2的硬币买下这件商品且两面值硬币数量差异最小的解法。(多组样例) 思路：把一枚1硬币和一枚2硬币捆绑成价值为3的硬币，先看能
华为机试（python）:字符串1
weixin_55118952的博客
03-05 2834
HJ5 进制转换 题目： 写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。 输入描述： 输入一个十六进制的数值字符串。 输出描述： 输出该数值的十进制字符串。不同组的测试用例用\n隔开。 while True: try: number = input() n = len(number) dic = {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'A'
【kmp算法】Substrings HDU - 1238
BlessingXRY的博客
10-11 374
Think: 1知识点：kmp算法 2题意：T组测试数据，每组测试数据输入n个字符串，询问最长长度的子串x，要求子串x或者子串x的翻转串在每个字符串中都会出现 3思路：找到最小的字符串，然后暴力枚举子串查询，剪枝优化 4反思： （1）：字符串长度为1的字符串不要忘记vjudge题目链接以下为Wrong Answer代码——未枚举字符串长度为1的字符串#include <cstdio> #i
笔试编程题：字符重排
qq_39527532的博客
09-08 1176
题目描述： 有一个字符串s,s中有n个字符，只可能是小写字母和数字组成，请将字符串的字母按照英文字典字母顺序排列，数字按从小到大排列，排序后的字符串疮毒与原字符串长度相同，但原位置的字符种类不能变更，如果原位置是数字仍是数字，原位置是字符串仍是字符串，如输入：hgfgfaada653234xx2de 输出：aaadddeffg223345gh6xx 输入描述： 输入一个数字T，表示有T组测试数据，对于每组测试数据，输入一个正整数n,表示字符串的长度，然后再输入字符串。 输出描述： 输出T行，每行按题目要求输
Codeforces Round #479 (Div. 3) E. Cyclic Components
01-03
E. Cyclic Components 题目链接-E. Cyclic Components 题目大意 给你nnn个点和mmm条边，求所构成图中单圈环的个数 解题思路 并查集并查集并查集 很明显单圈环每个点的度都为222，所以我们可以用数组cnt[]记录每...
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
一个长度为n的数组，为删除一些数后，剩下的数能否构成长度大于3的回文数组 思路： 只要能找到两个相等的数，且他们的间距大于2即可 o(n^2)的暴力就能过 比赛时写了一个o(n)的 就是把所有相等的数放到一个vector里，...
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 ...#define rep(i,a,b) for(int i=a;i=b;i--) typedef long long l
Codeforces Round #371 (Div. 1)
dehs8915的博客
09-21 99
A： 题目大意： 在一个multiset中要求支持3种操作： 1.增加一个数 2.删去一个数 3.给出一个01序列,问multiset中有多少这样的数,把它的十进制表示中的奇数改成1,偶数改成0后和给出的01序列相等(比较时如果长度不等各自用0补齐) 题解： 1.我的做法是用Trie数来存储,先将所有数用0补齐成长度为18位,然后就是Trie的操作了。 2.官方题解...
Codeforces Round #744 (Div. 3)部分题解
山中一扶苏的博客
10-11 5638
开始前，我还是想提前庆祝一下，第一次写这么多题的题解QwQ~~。 A 点击此处查看对应的题目. 本题模拟 直接统计a，b，c 的字母数量，最后判断c数量是否等于a+b数量。 时间复杂度 O(n)O(n)O(n) #include<bits/stdc++.h> using namespace std; const int N = 1e5 + 10,INF = 1e9 + 1; int a,b,c; void solve() { a = 0,b = 0,c = 0; string s;
Codeforces Round #744 (Div. 3) 题解 完整A~G
spy20051623的博客
10-14 250
Codeforces Round #744 (Div. 3) 题解 A. Casimir’s String Solitaire 题意 给出一个仅由字符’A’,‘B’,‘C’构成的字符串，每次可以同时消去一个’A’和一个’B’，或同时消去一个’B’和一个’C’，问最终能否消去所有字符。 思路 只需’B’的个数与’A’,'C’的个数之和相等即可全部消除。 时间复杂度 O(1) O(1) O(1) AC代码 Problem Lang Verdict Time Memory A - Casimir’
Codeforces Round #744 (Div. 3)
题解的个人总结，仅供参考
11-18 411
题目 这是一场欢乐场（div3）的题目。当时写这道题目，想得太复杂了。就是先将数组进行从小到大的排序，排序之后的位置为l,寻找在原序列中值相同的位置r（即使有重复的值，也没有关系，标记一下就行了），然后对原序列进行操作（这个也有规律的，自己举个栗子，就知道了），直到排序完成。就是一道单纯的模拟题。 #include <bits/stdc++.h> using namespace std; const int N=55; #define T int T; scanf("%d", &T);
Codeforces Round #744 (Div. 3)(A-E2)
weixin_49824291的博客
10-01 217
首先,庆祝自己上了绿名 A. Casimir’s String Solitaire 题目描述: 一个字符串包括A,B,C三种字符,有俩种操作可以选择 1.删除一个A和一个B 2.删除一个B和一个C 问最后能不能将这个字符串清空 思路: 统计A,B,C的数量为a,b,c,b=a+c则YES,否则NO #include<bits/stdc++.h> using namespace std; #define int long long signed main(){ int t; cin&gt
Codeforces Round #744 (Div. 3)简训
C_eeking的博客
11-05 289
Codeforces Round #744（Div.3）简训
Codeforces Round #734 (Div. 3) 题解
实验楼--动手做实验，轻松学IT！
07-27 452
Hello大家好，今天给大家带来的是 Codeforces Round #734 (Div. 3) 的全题目讲解。 本文链接：https://www.lanqiao.cn/questions/204012 感谢蓝桥云课的 Lqyk 同学提供的题解。 A. Polycarp and Coins 题目链接 https://codeforces.com/contest/1551/problem/A 题目大意 有一个人买东西付钱只用一元钱和二元钱， 现在他要付 nnn 元， 他使用一元钱的数量和二元钱数量的差值要
Codeforces Round #734 (Div. 3)题解
PengHao666999的博客
07-24 196
B2. Wonderful Coloring - 2 题目的基本意思： 1：每个元素要么不涂，要么只能涂一种颜色； 2：每一种颜色涂的元素两两都是不相同的; 3：每一种颜色涂的元素的个数时相同的； 4：最后序列中涂的元素的个数要最大； 解题的思路： 1：去掉没必要涂的元素 （1）该元素在序列中的个数要大于k(k表示颜色的总数)，将超过k的那部分直接用0表示即可，不用涂； （2）为了保证每一种颜色涂的元素的个数时相同的，所以最后涂的元素的总个数一定是k的整数倍 ...
codeforces round #734 (div. 3)
最新发布
03-16
Codeforces Round #734 (Div. 3) 是Codeforces平台上的一场比赛，属于Div.3级别，于2022年7月23日举行。这场比赛包括7道题目，难度较为适中，参赛选手需要在比赛时限内解决尽可能多的题目，以获得尽可能高的排名。该...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值