Codeforces Round #734 (Div. 3) A-D

最新推荐文章于 2024-06-18 23:03:44 发布

Clarence Liu

最新推荐文章于 2024-06-18 23:03:44 发布

阅读量87

点赞数

分类专栏： # 题目反思与总结

本文链接：https://blog.csdn.net/roadtohacker/article/details/119117770

版权

题目反思与总结专栏收录该内容

35 篇文章 0 订阅

订阅专栏

A题

给出一个数 $n$ ，现在要把它拆成 $n=c_1+2c_2$ ，并且要使得 $c_1-c_2|$ 最小，问 $c_1,c_2$ 的值

$\lfloor\frac{n}{3}\rfloor$ 必定是 $c_1$ 或者 $c_2$ ，分别讨论剩下情况即可

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <map>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 100;
int Data[MAXN];
int main(){
    int t;
    cin >> t;
    int n;
    while(t--){
        cin >> n;
        int m = n / 3;
        int k = n - m;
        if(k & 1){
            cout << n - 2 * m << " " << m << '\n';
        }else{
            cout << m << " " << (k >> 1) << '\n';
        }
    }
    return 0;
}

B1题

如果一个字符出现两次或者两次以上，一定是要涂一个红色的；同时统计只出现一次的字符数量，向下取整一半涂红色，另一半涂绿色

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <map>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 100;
int Data[60];
int vis[60];
int main(){
    ios::sync_with_stdio(false);
    int t;
    string s;
    cin >> t;
    while(t--){
        cin >> s;
        memset(Data, 0, sizeof Data);
        memset(vis, 0, sizeof vis);
        int len = s.length();
        int ans = 0;
        int num = 0;
        for(int i=0;i<len;i++){
            Data[s[i] - 'a']++;
        }
        for(int i=0;i<len;i++){
            if(Data[s[i] - 'a'] >= 2 && !vis[s[i] - 'a']){
                ans++;
                vis[s[i] - 'a'] = 1;
            }else if(Data[s[i] - 'a'] == 1){
                num++;
            }
        }
        ans += num / 2;
        cout << ans << '\n';
    }
    return 0;
}

B2题

现在颜色有 $k$ 种，如果涂多种颜色，每种颜色的数量相同，问涂色方案
思路很简单，我们要把数据划分成若干个 $k$ 组，在每组中分别涂 $1 - k$ 这些颜色，这样可以保证颜色之间是平衡的，关键是如何分组，可以把元素放到一个 $p a i r$ 中，方便统计答案
按照当前元素出现次数，边输入边统计，如果发现当前元素出现次数超过了 $k$ ，剩下的肯定不能涂色，否则加入到待涂色的数组中；对此数组按照元素大小排序，这样就可以保证相同元素之间颜色不冲突；最后枚举元素个数必须是 $k$ 的倍数

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <map>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 100;
int Data[MAXN];
int main(){
    ios::sync_with_stdio(false);
    int t, n, k;
    cin >> t;
    while(t--){
        cin >> n >> k;
        vector<int> vs(n);
        vector<int> ans(n);
        vector<pair<int, int>> b;
        map<int, int> mp;
        for(int i=0;i<n;i++){
            cin >> vs[i];
            mp[vs[i]]++;
            if(mp[vs[i]] <= k){
                b.push_back({vs[i], i});
            }
        }
        int cur = 0;
        sort(b.begin(), b.end());
        for(int i=0;i<b.size()/k*k;i++){
            ans[b[i].second] = cur + 1;
            ++cur;
            cur %= k;
        }
        for(auto i : ans) cout << i << " ";
        cout << '\n';
    }
    return 0;
}

C题

给出若干个字符串，选取若干个字符串组成一个 $i n t e r e s t i n g - s t o r y$ ，它的定义是含有某个字母的个数比其他字母个数和还多，问最多选择多少个字符串

考虑贪心，因为只有26个小写字母，枚举每一种可能的情况，假设是字母 $c$ ，那么统计每个字符串中字母 $c$ 的净量，也就是比其他字母多多少（有可能为负），统计完成以后，按照从多到少进行排序，从前往后选择同时记录现在字母 $c$ 的净量，如果大于0就更新答案

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <map>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 100;
int Data[MAXN];
int main(){
    ios::sync_with_stdio(false);
    int t, n;
    cin >> t;
    while(t--){
        cin >> n;
        vector<string> a(n);
        for(auto& i : a){
            cin >> i;
        }
        int ans = 0;
        for(char c='a';c<='z';c++){
            vector<int> b;
            int sum = 0;
            for(int i=0;i<n;i++){
                b.push_back(0);
                for(auto j : a[i]){
                    if(j == c) b.back()++;
                    else b.back()--;
                }
            }
            sort(b.rbegin(), b.rend());
            for(int i=0;i<b.size();i++){
                sum += b[i];
                if(sum > 0){
                    ans = max(ans, i + 1);
                }
            }
        }
        cout << ans << '\n';
    }
    return 0;
}

D1题

给出了一个 $n$ 行 $m$ 列的棋盘，现在要摆放满多米诺骨牌 $(d o m i n o)$ ，一个骨牌占两个格子，当然格子是相连的，给定摆放水平方向骨牌的数量，问能不能覆盖整个棋盘

其实很容易想到根据行数和列数进行奇偶分类讨论，但往下怎么处理
题目已经保证 $n\times m$ 为偶数，注意我们现在开始摆放水平方向的骨牌
当行数 $n$ 为奇数时，列数 $m$ 为偶数，我们尝试摆放第一行（为什么这么考虑，因为如果往下摆，始终解决不了行数为奇数的问题），如果摆不满显然不行，因为会剩下一部分奇数行，竖直方向的骨牌显然没办法摆放；如果能摆满，假设摆满之后剩下奇数个水平方向的骨牌，还是没办法摆放，因为列数是偶数，总会剩下一部分行数为奇数的空余位置，这样又回到了刚才的问题
当行数 $n$ 为偶数， $m$ 为奇数的时候，转换一下，尝试摆放第一列，和刚才的思路一样
当行数为偶数，列数也是偶数的时候，只要水平方向骨牌数量是偶数，那么就能摆放，否则不能

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <map>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 100;
int Data[MAXN];
int main(){
    ios::sync_with_stdio(false);
    int t, n, m, k;
    cin >> t;
    while(t--){
        cin >> n >> m >> k;
        int kv = ((n * m) >> 1) - k;
        bool ok = true;
        if(n & 1){
            k -= (m >> 1);
            if(k < 0){
                ok = false;
            }
        }else if(m & 1){
            kv -= (n >> 1);
            if(kv < 0){
                ok = false;
            }
        }
        if((k & 1) || (kv & 1)){
            ok = false;
        }
        cout << (ok ? "YES" : "NO") << '\n';
    }
    return 0;
}

D2题

按照刚才摆放的思路进行填充，这里需要注意细节，为了方便，填充第一行或者第一列这一步操作变成填充最后一行或者最后一列，因为横放的骨牌数量必然是偶数，刚才的操作结束后，没有摆放的位置行数和列数都是偶数，所以横放的骨牌一定要上面一个，下面一个，标号，直到摆放完毕，横放的摆完，摆竖着的，左面一个，右面一个，和刚才操作类似；这里根据横纵坐标确定标号，按奇数和偶数分开，保证标号不冲突

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <map>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 100;
int Data[MAXN];
char ans[200][200];
int main(){
    ios::sync_with_stdio(false);
    int n, m, k, t;
    cin >> t;
    while(t--){
        cin >> n >> m >> k;
        int kv = ((n * m) >> 1) - k;
        bool ok = true;
        if(n & 1){
            k -= (m >> 1);
            if(k < 0){
                ok = false;
            }
            for(int i=0;i<(m >> 1);i++){
                ans[n - 1][i << 1] = ans[n - 1][(i << 1) + 1] = (i & 1) ? 'x' : 'y';
            }
        }else if(m & 1){
            kv -= (n >> 1);
            if(kv < 0){
                ok = false;
            }
            for(int i=0;i<(n >> 1);i++){
                ans[i << 1][m - 1] = ans[(i << 1) + 1][m - 1] = (i & 1) ? 'x' : 'y';
            }
        }
        if((k & 1) || (kv & 1)) ok = false;
        if(!ok){
            cout << "NO" <<'\n';
        }else{
            cout << "YES" << '\n';
            for(int i=0;i<(n >> 1);i++){
                for(int j=0;j<(m >> 1);j++){ 
                    if(k > 0){
                        k -= 2;
                        ans[i << 1][j << 1] = ans[i << 1][(j << 1) + 1] = ((i + j) & 1) ? 'a' : 'b';
                        ans[(i << 1) + 1][(j << 1)] = ans[(i << 1) + 1][(j << 1) + 1] = ((i + j) & 1) ? 'c' : 'd';
                    }else{
                        ans[i << 1][j << 1] = ans[(i << 1) + 1][j << 1] = ((i + j) & 1) ? 'a' : 'b';
                        ans[i << 1][(j << 1) + 1] = ans[(i << 1) + 1][(j << 1) + 1] = ((i + j) & 1) ? 'c' : 'd';
                    }
                }
            }
            for(int i=0;i<n;i++){
                for(int j=0;j<m;j++){
                    cout << ans[i][j];
                }cout << '\n';
            }            
        }
    }
    return 0;
}

欢迎留言交流

Clarence Liu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Codeforces Round #734 (Div. 3) A-D

A题给出一个数nnn，现在要把它拆成n=c1+2c2n=c_1+2c_2n=c1+2c2，并且要使得∣c1−c2∣|c_1-c_2|∣c1−c2∣最小，问c1,c2c_1,c_2c1,c2的值⌊n3⌋\lfloor\frac{n}{3}\rfloor⌊3n⌋必定是c1c_1c1或者c2c_2c2，分别讨论剩下情况即可#include <iostream>#include <cstring>#include <algorithm>#incl
复制链接

扫一扫