Codeforces Round #354 (Div. 2) 大讨论之术+模拟+分层图+bfs

最新推荐文章于 2022-09-04 16:07:47 发布
最新推荐文章于 2022-09-04 16:07:47 发布
阅读量1k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： ===模拟赛=== ===基础算法=== 模拟 ===搜索=== 暴搜
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LOI_DQS/article/details/51509924
本文回顾了Codeforces Round #354（Div. 2）的比赛，讨论了A、B、C、D四道题目。A题和B题看似简单却易出错，C题需要考虑特殊情况，D题则是复杂的分层图BFS问题。作者反思了自己的错误，如C题的边界情况判断不全导致FST，D题因数组大小不足引发TLE。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

辣鸡CF 毁我青春

ABC三题都很SB，但需要大讨论之术或者代码写起来容易出错
D题一个一眼题，但写起来神烦，最终还卡了我数组大小
E我没看

最后C题惨遭FST，D后来改了改数组大小就过了，E还是没看

总结：不会写代码了

说白了还是人弱……

跪膜没FST并且rank44并且rating涨了二百多的yzy

掉了六十多rating，竟然这么少 不科学

A

题意：给一个排列，要求必须交换一次使得1和n的位置离得最远。

SB题，要特判一下奇怪的东西……代码写的丑

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<stack>
using namespace std;

typedef long long LL;
const int SZ = 200010;
const int INF = 1000000010;

int read()
{
    int n = 0;
    char a = getchar();
    bool flag = 0;
    while(a > '9' || a < '0') { if(a == '-') flag = 1; a = getchar(); }
    while(a >= '0' && a <= '9') { n = n * 10 + a - '0'; a = getchar(); }
    if(flag) n = -n;
    return n;
}

int num[SZ];

int main()
{
    int n = read();
    int pos1,pos2;
    for(int i = 1;i <= n;i ++)
    {
        num[i] = read();
        if(num[i] == 1) pos1 = i;
        if(num[i] == n) pos2 = i;
    }
    if(n == 1)
    {
        printf("0"); return 0;
    }
    if(n == 2)
    {
        printf("1"); return 0;
    }
    if(((pos1 == 1 && pos2 == n) || (pos1 == n || pos2 == 1)))
    {
        printf("%d",n - 1);
        return 0;
    }
    printf("%d\n",max(max(abs(n - pos1),abs(1 - pos1)),max(abs(n - pos2),abs(1 - pos2))));
    return 0;
}

B

题意：给n行杯子，构成金字塔形，其中第i行i个杯子。每分钟往顶层的杯子灌一个杯子的量的水，问n排杯子在t时刻后有多少个杯子是满的。

n<=10,0<=t<=10000

我竟然画了半天杨辉三角，最后还是写的模拟……这告诉我们不需要去想一些高端的算法只要能过就行了……

还有t=0的情况……

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;

typedef long long LL;
const int SZ = 200010;
const int INF = 1000000010;

int read()
{
    int n = 0;
    char a = getchar();
    bool flag = 0;
    while(a > '9' || a < '0') { if(a == '-') flag = 1; a = getchar(); }
    while(a >= '0' && a <= '9') { n = n * 10 + a - '0'; a = getchar(); }
    if(flag) n = -n;
    return n;
}

double bz[233][233],mi[233];

int n,t;

void dfs(int x,int y,double d)
{
    if(x == n + 1) return ;
    if(bz[x][y] == 1)
        dfs(x + 1,y,d / 2),dfs(x + 1,y + 1,d / 2);
    else
        bz[x][y] += d;
    return ;
}

int main()
{
    n = read(),t = read();
    double xxx = 1;
    for(int i = 1;i <= n;i ++)
        mi[i] = xxx,xxx /= 2.0;
    while(t --)
        dfs(1,1,1);
    int ans = 0;
    for(int i = 1;i <= n;i ++)
        for(int j = 1;j <= i;j ++)
            if(abs(bz[i][j] - 1.0) < 1e-8)
                ans ++;
    printf("%d",ans);
    return 0;
}

C

题意：给一个只含有a和b的字符串，要求最多修改k个字符使得最长连续相同字符长度最长。输出最长长度。

n<=10w,0<=k<=n

把a和b的出现位置单独存起来，每次修改k个字符必定是连续的k个a或者k个b，答案可以由区间左右端点所在位置更新。注意要由n或1更新的情况。

若有少于k个a或者k个b，答案是n

还要判一下k=0的情况。

FST原因：k=0的时候，没有判由1或者n更新的情况。
浪费大量时间原因：vector的.size()是unsigned类型，当vector为空的时候，.size()-1会RE

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;

typedef long long LL;
const int SZ = 200010;
const int INF = 1000000010;

int read()
{
    int n = 0;
    char a = getchar();
    bool flag = 0;
    while(a > '9' || a < '0') { if(a == '-') flag = 1; a = getchar(); }
    while(a >= '0' && a <= '9') { n = n * 10 + a - '0'; a = getchar(); }
    if(flag) n = -n;
    return n;
}

vector<int> a,b;

char s[SZ];

int main()
{
    int n = read(),k = read();
    scanf("%s",s + 1);
    for(int i = 1;i <= n;i ++)
        if(s[i] == 'a') a.push_back(i);
        else b.push_back(i);
    if(k == 0)
    {
        int ans = 0;
        for(int i = 0;i < (int)a.size() - 1;i ++)
            ans = max(ans,a[i + 1] - 1 - (a[i] + 1) + 1);
        if(a.size() == 1)
            ans = max(ans,max(a[0] - 1,n - a[0]));
        for(int i = 0;i < (int)b.size() - 1;i ++)
            ans = max(ans,b[i + 1] - 1 - (b[i] + 1) + 1);
        if(b.size() == 1)
            ans = max(ans,max(b[0] - 1,n - b[0]));
        if(a.size() <= k || b.size() <= k)
            ans = n;
        printf("%d\n",ans);
        return 0;
    }
    int ans = 0;
    for(int i = 0;i < (int)a.size();i ++)
    {
        int r = i + k - 1;
        if(r >= a.size()) break;
        if(i == 0)
        {
            if(r + 1 >= 0 && r + 1 < a.size())
                ans = max(ans,a[r + 1] - 1);
        }
        else if(r == (int)a.size() - 1)
        {
            if(i - 1 >= 0)
                ans = max(ans,n - (a[i - 1] + 1) + 1);
        }
        else
        {
            if(r + 1 >= 0 && r + 1 < a.size() && i - 1 >= 0)
                ans = max(ans,(a[r + 1] - 1) - (a[i - 1] + 1) + 1);
        }
    }
    for(int i = 0;i < (int)b.size();i ++)
    {
        int r = i + k - 1;
        if(r >= b.size()) break;
        if(i == 0)
        {
            if(r + 1 >= 0 && r + 1 < b.size())
                ans = max(ans,b[r + 1] - 1);
        }
        else if(r == (int)b.size() - 1)
        {
            if(i - 1 >= 0)
                ans = max(ans,n - (b[i - 1] + 1) + 1);
        }
        else
        {
            if(r + 1 >= 0 && r + 1 < b.size() && i - 1 >= 0)
                ans = max(ans,(b[r + 1] - 1) - (b[i - 1] + 1) + 1);
        }
    }
    if(a.size() <= k || b.size() <= k)
        ans = n;
    printf("%d",ans);
    return 0;
}

D

题意：n*m的迷宫，每个格子有四面，每一面都有可能有门，这样一共是16种格子。每分钟你可以从一个格子透过门走到另一个相邻的格子，要求两个格子都有相应的门；或者人原地不动，所有的格子原地瞬时针旋转90度。问给定起点到给定终点的最短路。

n<=m<=1000

SB分层图BFS，代码神烦

边数在全都是四连通的时候达到最大，大概边要达到一千多万，数组开2000w比较保险

数组开小他说我TLE，我以为On算法被卡常，调了半天……

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
#include<queue>
using namespace std;

typedef long long LL;
const int SZ = 4000010;
const int INF = 1000000010;

int read()
{
    int n = 0;
    char a = getchar();
    bool flag = 0;
    while(a > '9' || a < '0') { if(a == '-') flag = 1; a = getchar(); }
    while(a >= '0' && a <= '9') { n = n * 10 + a - '0'; a = getchar(); }
    if(flag) n = -n;
    return n;
}

string mp[200];

const int dx[] = {0,1,0,-1};
const int dy[] = {1,0,-1,0};//右 下 左 上 

char maps[1010][1010];

int n,m;

bool iscan(int x,int y)
{
    return x >= 1 && x <= n && y >= 1 && y <= m;
}

int getnode(int x,int y,int d)
{
    return (x - 1) * m + y + (d - 1) * n * m; 
}

int head[SZ],nxt[20000000],tot = 1;

struct edge{
    int t;
    bool d;
}l[20000000];

void build(int f,int t,int d)
{
    l[++ tot] = (edge){t,d};
    nxt[tot] = head[f]; head[f] = tot;
}

bool vis[SZ];
struct haha{
    int u,d;
};
queue<haha> q;

int bfs(int s,int e)
{
    q.push((haha){s,0});
    vis[s] = 1;
    while(q.size())
    {
        haha f = q.front(); q.pop();
        for(int i = head[f.u];i;i = nxt[i])
        {
            int v = l[i].t;
            if(!vis[v])
            {
                vis[v] = 1;
                if(v == e) return f.d + l[i].d;
                q.push((haha){v,f.d + l[i].d});
            }
        }
    }
    return -1;
}

int main()
{
    mp['+'] = "1111";
    mp['-'] = "1010";
    mp['|'] = "0101";
    mp['^'] = "0001";
    mp['>'] = "1000";
    mp['<'] = "0010";
    mp['v'] = "0100";
    mp['L'] = "1101";
    mp['R'] = "0111";
    mp['U'] = "1110";
    mp['D'] = "1011";
    mp['*'] = "0000";
    n = read(),m = read();
    for(int i = 1;i <= n;i ++)
        gets(maps[i] + 1);
    int sx = read(),sy = read(),ex = read(),ey = read();
    for(int p = 1;p <= 4;p ++)
    {
        for(int i = 1;i <= n;i ++)
        {
            for(int j = 1;j <= m;j ++)
            {
                for(int k = 0;k < 4;k ++)
                {
                    int p1 = (k - (p - 1) + 4) % 4;
                    int p2 = (p1 + 2) % 4;
                    int x = i + dx[k],y = j + dy[k];
                    if(iscan(x,y))
                    {
                        if(mp[maps[i][j]][p1] == '1' && mp[maps[x][y]][p2] == '1')
                            build(getnode(i,j,p),getnode(x,y,p),1);//printf("%d %d %d %d %d %d %d %d\n",i,j,x,y,p1,p2,p,k);
                    }
                }
            }
        }
    }
    for(int i = 1;i <= n;i ++)
    {
        for(int j = 1;j <= m;j ++)
        {
            build(getnode(i,j,1),getnode(i,j,2),1);
            build(getnode(i,j,2),getnode(i,j,3),1);
            build(getnode(i,j,3),getnode(i,j,4),1);
            build(getnode(i,j,4),getnode(i,j,1),1);
        }
    }   
    int e = n * m * 4 + 1;
    build(getnode(ex,ey,1),e,0);
    build(getnode(ex,ey,2),e,0);
    build(getnode(ex,ey,3),e,0);
    build(getnode(ex,ey,4),e,0);
    printf("%d",bfs(getnode(sx,sy,1),e));
    return 0;
}
/*
2 3
<><
><>
1 1
1 1
*/
[cf1473e]Minimum Path(分层图最短路)
seeeagull
01-17 411
是个分层图的问题。感觉知道的话似乎很容易就想到了，不知道的话……大概就不知道了qwq。 分层图就是说，如果在一个带权图上，我们对于每条路径都可以将其中k条边做一些改变，比如不计算其权值，那么我们就先建k+1层完全相同的初始图（权值为原值），然后层之间的连边情况不变，但权值为改变之后的。 比如如果图是1、2、3两两之间连一条权值为1的边，一条路径上可以有一条边不计算权值，求1到各点最短路。那么我们建图分两层，一层的1、2、3两两间连边权值为1，二层的1'、2'、3'两两间连边权值为1，然后1->2'
挑战程序设计：Codeforces Round #776 (Div. 3) G. Counting Shortcuts(最短路计数+分层DP)
m0_52186223的博客
03-09 498
题目传送门 题目大意： 给定一张无自环无重边的无向图G,以及起点和终点S和T，边权都为1，求从S到T的路径长度<=最短路长度+1的数量。 解题思路 由于边权长度恒定为1，因此最短路计数十分简单，利用bfs即可，前时间复杂度为稳定的O(2m)。无需使用spfa或者djstra。 当我们获得最短路的数量后，我们就需要考虑对于某一点如何求其最短路+1的路径数量。 对于点x,设其距离S的最短路长度为midis,有哪些点会更新该点的最短路+1的数量。 假设点x与点y联通： 当点y的dis>midis时，
（分层图）CF1473E. Minimum Path
Z7784562的博客
01-17 215
CF1473E. Minimum Path 题意： 给你一个无向图，一条长度为kkk的路径e1,e2,⋯ ,eke_1,e_2,\cdots,e_ke1​,e2​,⋯,ek​的权值为∑i=1kwei−max⁡i=1kwei+min⁡i=1kwei\sum\limits_{i=1}^k w_{e_i}-\max\limits_{i=1}^{k} w_{e_i}+\min\limits_{i=1}^{k} w_{e_i}i=1∑k​wei​​−i=1maxk​wei​​+i=1mink​wei​​,问从111到
CF1442C Graph Transpositions 分层图
Zenith_Habitant的博客
11-06 361
题目链接：https://codeforces.com/problemset/problem/1442/C 解题思路：发现当反转18次的时候，代价是超过最大的m的，所以分开讨论，首先计算出从起点到达终点最少需要多少次反转，如果超过18次，按最少次数转移，同时计算出最少次数下的最短路，当小于18次时，这个时候，所需要的所有代价不会超过long long（所以取模后不会丢失大小关系），所以可以直接使用dijkstra求解 //#define LOCAL #include <bits/stdc++.h&.
CF1442C Graph Transpositions 分层图 最短路 （无代码）
forever_shi的博客
11-18 298
题目链接 题意： 给你一个nnn个点mmm条边的有向图，有一个东西一开始在111号点，要最快的走到nnn号点。无重边自环。 有两种操作：第一种是花费111的时间走一条边，第二种是花费2k−12^{k-1}2k−1的时间将图上所有边反向，kkk表示当前是这个操作第kkk次进行。 求从111到nnn的最短时间。 由于翻转操作会让答案很大，所以答案模998244353998244353998244353 题目保证有解。 1<=n,m<=2e51<=n,m<=2e51<=n,m<
CF1137C:Museums Tour（缩点、分层图）
BUG_Creater_jie的博客
11-15 354
解析 比起CF，更像是主题库的一道题 也是很好的一道题 由于可以在环里转圈，容易想到缩点 但是出现了一个问题：缩点是无法统计一个强连通分量里有哪些环及其大小的 而本题中显然环的大小和d的关系至关重要 考虑转换思路 把每个城市x割成d个点(x,1)到(x,d) 每个点表示第i天到达该城市 对新图跑tarjan 每个分量记录其不同的博物馆的数目 可以利用一个带标记的桶来解决 最后跑一遍简单的dp即可 为什么这样不会重复统计？ 假设(x,i)走到了不在同一个分量里的(x,i+w)，使城市x被统计了两遍 那么x就在
Codeforces Round #565 (Div. 3)
既然弱小，就只顾变强就是了
06-10 336
A. Divide it! 直接暴力求解，看看能不能用上面的这几种方法使得给出的数变成1？ #include <iostream> #include <cstdio> #include <cmath> #include <string> #include <cstring> #include <algorithm> ...
Codeforces Round #818 (Div.2)F(最大流)
lihua777的博客
09-04 502
Codeforces Round #818 (Div.2)F(最大流)
【CodeForces】CodeForces Round #517 (Div. 1 + Div. 2) 题解
cz_xuyixuan的博客
10-22 733
【比赛链接】 Div. 1 Div. 2 【题解链接】 点击打开链接 **【Div.2 A】**Golden Plate 【思路要点】 直接循环计算答案即可。 时间复杂度 O(K)O(K)O(K) 。 【代码】 #include&lt;bits/stdc++.h&gt; using namespace std; const int MAXN = 2e5 + 5; type...
【uoj#150】【NOIP2015】运输计划 树上前缀和+lca+二分+拓扑排序+特别的卡常数技巧
DQS的树洞
03-08 2135
公元 2044 年，人类进入了宇宙纪元。L 国有 nn 个星球，还有 n−1n−1 条双向航道，每条航道建立在两个星球之间，这 n−1n−1 条航道连通了 LL 国的所有星球。小 P 掌管一家物流公司， 该公司有很多个运输计划，每个运输计划形如：有一艘物流飞船需要从 uiui 号星球沿最快的宇航路径飞行到 vivi 号星球去。显然，飞船驶过一条航道是需要时间的，对于航道 jj，任意飞船驶过它所花费的
【codevs1959】拔河比赛 随机化贪心
DQS的树洞
10-27 1990
题目描述 Description一个学校举行拔河比赛，所有的人被分成了两组，每个人必须（且只能够）在其中的一组，要求两个组的人数相差不能超过1，且两个组内的所有人体重加起来尽可能地接近。输入描述 Input Description数据的第1行是一个n，表示参加拔河比赛的总人数，n<=100，接下来的n行表示第1到第n个人的体重，每个人的体重都是整数（1<=weight<=450）。输出描述 Outp
【bzoj4551】[Tjoi2016&Heoi2016]树 暴力？树剖+树状数组+二分
DQS的树洞
04-28 1832
Description在2016年，佳媛姐姐刚刚学习了树，非常开心。现在他想解决这样一个问题：给定一颗有根树（根为1），有以下 两种操作：1. 标记操作：对某个结点打上标记（在最开始，只有结点1有标记，其他结点均无标记，而且对于某个 结点，可以打多次标记。）2. 询问操作：询问某个结点最近的一个打了标记的祖先（这个结点本身也算自己的祖 先）你能帮帮他吗?Input输入第一行两个正整数N和Q分别
【NOIP2010】引水入城 DFS+贪心
DQS的树洞
10-28 1599
题目有图，不附了，好麻烦……http://codevs.cn/problem/1066/我的想法是：对于第一排每个点都做一遍dfs，获得它能控制的区间（回溯时更新）。可以证得，如果它控制的区间不是一个（也就是中间有中断），那么必定不可全部覆盖。每个点一遍dfs，时间复杂度太高，还有可能爆栈，记忆化一下就好了，这样的话时间复杂度也可以承受，这玩意我写疵了…调了好久…早知道就不做死打dfs了……bfs其
【bzoj3035】【codevs2490】导弹防御塔 二分+匈牙利 || 二分+dinic
DQS的树洞
03-02 1290
题目描述 Description　　Freda的城堡—— 　　“Freda，城堡外发现了一些入侵者！” 　　“喵…刚刚探究完了城堡建设的方案数，我要歇一会儿嘛lala~” 　　“可是入侵者已经接近城堡了呀！” 　　“别担心，rainbow，你看呢，这是我刚设计的导弹防御系统的说~” 　　“喂…别卖萌啊……”　　Freda控制着N座可以发射导弹的防御塔。每座塔都有足够数量的导弹，但是每座塔每
【poj2104】K-th Number 分块
DQS的树洞
09-19 1264
DescriptionYou are working for Macrohard company in data structures department. After failing your previous task about key insertion you were asked to write a new data structure that would be able to r
【湖南师大附中培训】2016.3.26测试题 后缀数组+二分+贪心+dp+hash
DQS的树洞
03-27 1235
早上去晚了…八点开始的我快九点才到…那个老师说好的八点半集合结果没看见人…逗我呢…也就这次考得稍好点了，坐看其他几场各位大爷们AK…Orzfqk Orzyzy Orz龙哥 等等等等…100+60+10……T3数据范围写的20分m<=5，然后第二个点m=6…然后我特判若m<=5则dfs…坑我呢？T1题意：给个字符串，划分不超过K份，从每份中选出字典序最大的子串，然后从这些串中选出字典序最大的串，求问这
【JSOI2007】建筑抢修 贪心+堆
DQS的树洞
10-13 1201
Description小刚在玩JSOI提供的一个称之为“建筑抢修”的电脑游戏：经过了一场激烈的战斗，T部落消灭了所有z部落的入侵者。但是T部落的基地里已经有N个建筑设施受到了严重的损伤，如果不尽快修复的话，这些建筑设施将会完全毁坏。现在的情况是：T部落基地里只有一个修理工人，虽然他能瞬间到达任何一个建筑，但是修复每个建筑都需要一定的时间。同时，修理工人修理完一个建筑才能修理下一个建筑，不能同时修理多
【poj1057】FILE MAPPING 模拟
DQS的树洞
07-14 1179
DescriptionIt is often helpful for computer users to see a visual representation of the file structure on their computers. The “explorer” in Microsoft Windows is an example of such a system. Before the
【NOIP2011】聪明的质检员 二分
DQS的树洞
10-27 1169
二分。 如何O（n）检验？ 做一个大于w的v的前缀和，出现次数的前缀和，就可以O（m+n）查询检验了。若要直接分答案，则是单谷函数，需要三分，但若分w，是单调函数，只需要二分。哦对，不开longlong会死。代码：#include<cstdio> #include<iostream> #include<cstring> #include<algorithm> using namespace st
codeforces round #792 (div. 1 + div. 2)
06-06
codeforces round #792 (div. 1 + div. 2) 是 Codeforces 竞赛平台上的一场比赛，包括两个级别：div. 1 和 div. 2。这场比赛通常会有多个问题需要参赛者解决，每个问题都有不同的难度等级。参赛者需要在规定的时间内提交他们的解决方案，然后等待评测结果。最终，根据参赛者的得分和排名，评选出获胜者。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值