codeforces round937 div4

最新推荐文章于 2024-11-09 20:38:27 发布
置顶 最新推荐文章于 2024-11-09 20:38:27 发布
阅读量260 收藏 10
点赞数 3
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75845839/article/details/139066659
版权

A. Stair, Peak, or Neither?

问题：

思路：枚举所有合法情况

代码：

#include <iostream>
 
using namespace std; 
 
void solve() {
    int a, b, c;
    cin >> a >> b >> c;
    if(a < b && b < c) cout << "STAIR" << endl;
    else if(a < b && b > c) cout << "PEAK" << endl;
    else cout << "NONE" << endl;
}
 
int main() {
    int t;
    cin >> t;
    while(t -- ) {
        solve();
    }
    return 0;
}

B upscaling

题目：

思路：两个for循环，按照奇数遍历次数和偶数遍历次数分别填充方块

代码：

#include <iostream>
 
using namespace std;
 
const int N = 22;
 
char g[2 * N][2 * N];
 
void get(int a, int b, char c) {
    g[(a - 1) * 2 + 1][(b - 1) * 2 + 1] = c;
    g[(a - 1) * 2 + 1][(b - 1) * 2 + 2] = c;
    g[(a - 1) * 2 + 2][(b - 1) * 2 + 1] = c;
    g[(a - 1) * 2 + 2][(b - 1) * 2 + 2] = c;
}
 
void solve() {
    int n;
    cin >> n;
 
    int w = 1;
 
    for(int i = 1; i <= n; i ++ ) {
        if(i % 2) {
            for(int j = 1; j <= n; j ++ ) {
                char c;
                if(w ++ % 2) c = '#';
                else c = '.';
                get(i, j, c);
            }
        } else {
                for(int j = n; j; j -- ) {
                    char c;
                    if(w ++ % 2) c = '#';
                    else c = '.';
                    get(i, j, c);
                }
            }
    }
 
    for(int i = 1; i <= 2 * n; i ++ ) {
        for(int j = 1; j <= 2 * n; j ++ ) {
            cout << g[i][j];
        }
        cout << endl;
    }
}
 
int main() {
    int t;
    cin >> t;
 
    while(t -- ) {
        solve();
    }
    return 0;
}

C time conversion

问题：

思路：模拟

代码：

#include <iostream>
 
using namespace std;
 
void solve() {
    string str;
    cin >> str;
    
    char a = str[0];
    char b = str[1];
    string Time;
 
    int t = (b - '0' + (a - '0') * 10);
    if(t < 12) Time = " AM";
    else Time = " PM";
    t %= 12;
 
    if(t == 0) cout << "12";
    else if(t < 10) cout << "0" << t;
    else cout << t;
 
    for(int i = 2; str[i]; i ++ ) cout << str[i];
    cout << Time;
    cout << endl;
}
 
int main() {
    int t;
    cin >> t;
    while(t -- ) {
        solve();
    }
    return 0;
}

D product of binary decimals

问题:

思路：由于1到1e5的十进制二进制数很少，因此考虑爆搜。注意1不能加到我们的bd集合中去，否则dfs会一直递归下去

代码：

#include <iostream>
#include <vector>

using namespace std;

bool flag;
vector<int> bd;
 
bool get(int x) {
    while(x) {
        if(x % 10 > 1)
            return false;
        x /= 10;
    }
    return true;
}

void dfs(int x) {
    if(x == 1) {
        flag = true;
        return;
    }
    for(auto t: bd) {
        if(!(x % t)) dfs(x / t);
    }
}

void solve() {
    flag = false;
    int n;
    cin >> n;
    dfs(n);
    if(flag) cout << "YES" << endl;
    else cout << "NO" << endl;
}

int main() {
    for(int i = 2; i <= 1e5; i ++ ) {
        if(get(i)) bd.push_back(i);
    }
    //for(auto t: bd) cout << t << " ";
    int t;
    cin >> t;
    while(t -- ) {
        solve();
    }
    return 0;
}


 

E nearly shortest repeating substrings

问题：

思路：可以暴力枚举字符串长度的所有约数，对于每个约数判断该约数构成的字符串是否合法。

在判断最多有一个字符不同时由于我们不知道该字符是在开头还是在其他地方，多次判断代码极其复杂，这里可以考虑从前向后搜一遍，从后向前搜一遍

代码：

#include <iostream>
#include <cstring>
 
using namespace std;
 
void solve() {
    int n;
    string str;
    cin >> n >> str;
 
    for(int k = 1; k <= n; k ++ ) {
        if(n % k) continue;
        bool flag = true, flag1 = true;
        int cnt = 1;
        string str1 = str.substr(0, k);
        for(int i = 0, j = 0; i < n; i ++ ) {
            if(str[i] != str1[j]) {
                if(!cnt) {
                    flag = false;
                    break;
                }
                cnt --;
            }
            j ++;
            if(j == k) j = 0;
        }
 
        cnt = 1;
        string str2 = str.substr(str.size() - k);
 
        for(int i = str.size() - 1, j = k - 1; i >= 0; i -- ) {
                if(str[i] != str2[j]) {
                    if(!cnt) {
                        flag1 = false;
                        break;
                    }
                    cnt --;
                }
                j --;
                if(j < 0) j = k - 1;
        }
        if(flag || flag1) {
            cout << k << endl;
            return;
        } 
    }
}
 
int main() {
    int t;
    cin >> t;
 
    while(t -- ) {
        solve();
    }
    return 0;
}


F 012 tree

问题：

思路： 模拟

代码：

#include <iostream>
 
using namespace std;
 
void build() {
 
}
 
void solve() {
    int a, b, c;
    cin >> a >> b >> c;
    
    int twoChil = 1;
    int num = 1;
    int high = 1;
 
    while(twoChil < a) {
        twoChil += num * 2;
        num *= 2;
        high ++;
    } 
    int last = twoChil - a;
    int pre = num - last;
    if(c != pre * 2 + last) cout << "-1" << endl;
    else {
        if(b <= last) {
            if(b && pre == 0) cout << high << endl;
            else cout << high - 1 << endl;
        } else {
            b -= last;
            int cnt = pre * 2 + last;
            if(b % cnt) cout << high + 1 + b / cnt << endl;
            else cout << high + b / cnt << endl;
            }
    }
}
 
int main() {
    int t;
    cin >> t;
 
    while(t -- ) {
        solve();
    }
    return 0;
}

G suffering songs

问题：

思路：状态压缩dp。首先观察题目数据，n在18之内，这时可以考虑爆搜＋减枝。如果不是题目有明显的可以舍去绝大部分情况的剪枝策略，18这个范围往往会tle，因为歌曲还要求排序。这时候可以考虑状态压缩dp，用二进制数表示出所有状态，2^18并不是一个很大的数，不用担心mle的问题。我们用二进制数，即0， 1串表示出状态后，要考虑如何进行状态转移。我们往序列后添加歌曲的条件是添加的歌曲与序列最后的歌曲音乐类型与作者是否相同，因此可以给dp数组再加上一维，表示目前状态最后一个歌曲的编号，如果i号歌曲在01串对应的需要为0，并且该歌曲与末尾歌曲可以匹配，那么此时i与01串对应位置要置1，并且数组二维下标要变成i

注意，多次比较字符串的操作较慢，最后会t33，这里可以先对字符串进行预处理，或者把字符串映射成数字,第二种操作类似于离散化

代码：
爆搜tle代码，能想到的剪枝策略都用上了，最后t33了：

#include <iostream>
#include <cstring>
#include <algorithm>
 
using namespace std;
 
const int N = 20;
 
int n;
struct Song{
    string style;
    string author;
    int cnt;
    bool operator < (const Song &W) const {
        return cnt < W.cnt;
    }
}song[N];
bool st[N], flag;
 
bool cmp(int a, int b) {
    return a > b;    
}
 
void dfs(int cnt, int u, int num) {
    if(cnt == n - num) {
        flag = true;
        return;
    }
    if(cnt == 0) {
        for(int i = n; i >= 1; i -- ) {
            st[i] = true;
            dfs(cnt + 1, i, num);
            st[i] = false;
        }
    } else {
    for(int i = n; i >= 1; i -- ) {
            if(!st[i] && (song[u].author == song[i].author || song[u].style == song[i].style)) {
                st[i] = true;
                dfs(cnt + 1, i, num);
                st[i] = false;
            }
        }
    }
}
 
void solve() {
    flag = false;
    cin >> n;
 
    for(int i = 1; i <= n; i ++ ) {
        string a, b;
        cin >> a >> b;
        song[i] = {a, b};
    }
    
    for(int i = 1; i <= n; i ++ ) {
        for(int j = 1; j <= n; j ++ ) {
            if(i == j) continue;
            if(song[i].author == song[j].author || song[i].style == song[j].style) song[i].cnt ++;
        }
    }
    
    sort(song + 1, song + 1 + n);
    
    for(int i = 0; i < n; i ++ ) {
        memset(st, 0, sizeof st);
        dfs(0, 0, i);
        if(flag) {
            cout << i << endl; 
            return;
        }
    }
}
 
int main() {
    int t;
    cin >> t;
 
    while(t -- ) {
        solve();
    }
    return 0;
}

状态压缩ac代码（这里是映射思路）：
 

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
 
using namespace std;
 
const int N = 20;
 
bool dp[1 << N][N];
pair<string, string> s[N];
int fir[N], sec[N];
int n;
 
int calc(int x) {
    int cnt = 0;
    while(x) {
        if(x & 1) cnt ++;
        x >>= 1;
    }   
    return cnt;
}
 
int find(string a, vector<string> &aa) {
    int l = 0, r = aa.size() - 1;
    while(l < r) {
        int mid = l + r >> 1;
        if(aa[mid] >= a) r = mid;
        else l = mid + 1;
    }
    return l;
}
 
void solve() {
    vector<string> aa;
    cin >> n;
    
    for(int i = 0; i < 1 << n; i ++ ) {
        for(int j = 0; j < n; j ++ ) {
            dp[i][j] = false;
        }
    }
    
    for(int i = 0; i < n; i ++ ) {
        string a, b;
        cin >> a >> b;
        s[i] = {a, b};
        aa.push_back(a);
        aa.push_back(b);
    }
    
    sort(aa.begin(), aa.end());
    aa.erase(unique(aa.begin(), aa.end()), aa.end());
    
    for(int i = 0; i < n; i ++ ) {
        fir[i] = find(s[i].first, aa);
        sec[i] = find(s[i].second, aa);
    }
    
    for(int i = 0; i < n; i ++ ) dp[1 << i][i] = true;
 
    for(int i = 0; i < 1 << n; i ++ ) {
        for(int j = 0; j < n; j ++ ) {
            if(!dp[i][j]) continue;
            else {//状态转移
                for(int k = 0; k < n; k ++ ) {
                    if(!(i >> k & 1)) {
                        if(fir[k] == fir[j] || sec[k] == sec[j]) {
                            dp[i | (1 << k)][k] = true;
                        }
                    }
                }
            }
        }
    }
    
    int res = 0;
    for(int i = 0; i < 1 << n; i ++ ) {
        for(int j = 0; j < n; j ++ ) {
            if(dp[i][j]) {
                res = max(res, calc(i));
            }
        }
    }
    cout << n - res << endl;
}
 
int main() {
    int t;
    cin >> t;
    while(t -- ) {
        solve();
    }
    return 0;
}

预处理的方法比较简洁：

for(int i = 0; i < n; i ++ ) {
        for(int j = 0; j < n; j ++ ) {
            if(s[i].first == s[j].first || s[i].second == s[j].second) 
                g[i][j] = g[j][i] = 1;
        }
    }

'eiyuu
关注
Codeforces Round 937 (Div. 4) 题解（A-F）
Antonio915的博客
03-29 838
首先先判断一下是否能构成二叉树，构成二叉树的条件是：后代为2的节点*2+后代为1的节点+1=总结点，即：2*a+b+1=a+b+c。所以在构造时尽可能往满二叉树方向构造，即先使用后代为2的点，然后再使用后代为1的点，最后使用后代为0的叶子结点，当叶子结点不够则结束。筛选出字符串长度的所有因子，然后枚举因子，用map存下所有的子串大小，判断不同子串的个数，如果子串个数为1，则直接成立。如果不同子串个数为2，并且其中一个子串只有一个，那么判断一下不同的两个子串不同的字符个数，若为1，则成立，反之，不成立。
Codeforces Round 871 (Div. 4)
m0_65907991的博客
05-07 978
思路：先求出图的最长直经，找到直径的两个端点，和直径长度。直径的中点就是根节点，它的度数就是。看每本书都有对应的代价，求学会两种技能的最小代价。，可以用二分求出它所在的层数的上一层是第几层，令其为。然后就可以分3种情况得到直接位于它上方的部分的值。位于当前层的第一个，直接在其上方的部分就一个，值为。个变量维护三种类型各自的最小代价，最后得到答案。位于当前层最后一个，和第一种类似，其值为。，且3的个数大于2的个数就有解。题意：有一个图，其根节点直接与。，随便找个根节点直接相邻的节点。，直接在其上方的有两个。
Codeforces Round 965 (Div. 2) 8.10
2301_81692739的博客
08-11 915
看题得认真，不能迷糊，不然太费时间。
Codeforces Round 973 (Div. 2)
2301_79929720的博客
09-21 1104
Codeforces Round 973 (Div. 2)
Codeforces Round 974 (Div. 3)
ros275229的博客
09-22 658
也是模拟，找到最小不满足哪一个，求出应满足的最小值+1减去原来的sum即可;只用分情况(奇偶)讨论即可;
Codeforces Round 962 (Div3) A-C题解
2301_79967286的博客
07-27 928
题目大意：给定你两个字符串 每次给定一个范围l
Codeforces Round 918 (Div. 4)（AK）
weixin_61825750的博客
12-29 3425
A、模拟B、模拟C、模拟D、模拟E、思维，前缀和F、思维、逆序对G、最短路
Codeforces Round 966 (Div. 3)
2402_82371019的博客
08-14 544
初始化：逐步检查：结果： "NO"解释：初始化：逐步检查：结果： "YES"解释：初始化：逐步检查：结果： "YES"解释：初始化：逐步检查：结果： "NO"
Codeforces Round 937 (Div. 4)
m0_74015873的博客
03-29 714
【代码】Codeforces Round 937 (Div. 4)
Codeforces Round 952 (Div. 4)（实时更新）
weixin_73164943的博客
06-12 986
cf题集
Educational Codeforces Round 83 (Rated for Div. 2) D
01-20
今天CF被D恶心到了，写个题解重新整理下思路，（20开始想，25写完暴力代码，1.30才过，优化后的。。 核心思路就是在暴力的基础上进行组合数等差加速。 C(n-2,i-1)*C(j-1,n-2)*(i-1) __ j: n-1 -> m ...
Codeforces Round 964 (Div. 4).pdf
08-07
A~G
Codeforces Round 799 (Div. 4)
m0_73935863的博客
03-14 399
Codeforces Round 799 (Div. 4)
C 学习（4）
search7的博客
11-05 765
C语言学习，每个模块来自工作中的？？？
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 80
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
STL set
最新发布
hls0611的博客
11-09 104
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
常用的c++特性--＞day02
m0_69093426的博客
11-06 528
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
c++函数形参 返回两幅IplImage*图像
u012719076的博客
11-05 140
如果在GetImage函数中用cvCreateImage创建 p1 p2，则在调用时发现返回的数据是空的。主要是调用之前要先定义好。
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 198
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
Codeforces Round 961 Div. 2竞赛解析指南
资源摘要信息:"Codeforces Round 961 (Div. 2) 编程竞赛的详细解析" Codeforces是一个国际性的在线编程竞赛平台，它定期举办各种级别的编程比赛，其中包括面向初学者的Div. 2和面向高级程序员的Div. 1比赛。在这次...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值