AtCoder Beginner Contest 218-ABCDEF 题解

最新推荐文章于 2021-09-18 15:53:02 发布
最新推荐文章于 2021-09-18 15:53:02 发布
阅读量487 收藏 2
点赞数
分类专栏： acm c++ 文章标签： acm竞赛 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Reinhart_L/article/details/120254498
版权
c++ 同时被 2 个专栏收录
13 篇文章 0 订阅
订阅专栏
acm
12 篇文章 0 订阅
订阅专栏

https://atcoder.jp/contests/abc218/tasks

A - Weather Forecast

水题

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<unordered_map>
#include<set>
#pragma GCC optimize(2)
using namespace std;
#define ll long long
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define fi first
#define se second
#define pb push_back
#define debug(a) cout << #a << " " << a << '\n';
const int N=1e5+5;
const int M=1e5+5;
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const ll mod = 1e9 + 7;
int n,m;
int main(){
    //ios::sync_with_stdio(false);
    cin>>n;
    string s;
    cin>>s;
    if(s[n-1]=='o')cout<<"Yes";
    else{
        cout<<"No";
    }

    return 0;
}

B - qwerty

水题

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<unordered_map>
#include<set>
#pragma GCC optimize(2)
using namespace std;
#define ll long long
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define fi first
#define se second
#define pb push_back
#define debug(a) cout << #a << " " << a << '\n';
const int N=1e5+5;
const int M=1e5+5;
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const ll mod = 1e9 + 7;
inline ll read();
int n,m;
int a[30];
int main(){
    //ios::sync_with_stdio(false);
    for(int i=0;i<26;i++){
        cin>>a[i];
    }
    string s;
    for(int i=0;i<26;i++){
        s+=char(a[i]+'a'-1);
    }
    cout<<s;
    return 0;
}

C - Shapes

题意:

两个 N ∗ N N*N N∗N矩阵A,B都由*和#构成,你可以对B进行任意次90度旋转(正逆时针都可)和对#图形进行整体的平移,如果最后B能和A完全一样输出Yes,否则输出No

题解:

枚举每一种有效的旋转(最多三次),然后每次都将A和B的#图形移到最左上角,看#的数目和位置是否一致.

代码:
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<unordered_map>
#include<set>

#pragma GCC optimize(2)
using namespace std;
#define ll long long
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define fi first
#define se second
#define pb push_back
#define debug(a) cout << #a << " " << a << '\n';
const int N = 1e5 + 5;
const int M = 1e5 + 5;
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const ll mod = 1e9 + 7;

inline ll read();

int n, m;
#define ll long long
#define INF 0x3f3f3f3f
const int maxn = 205;
char a[maxn][maxn], b[maxn][maxn], c[maxn][maxn];
int cnt = 0;
map<pair<int, int>, int> ma;
vector<pair<int, int> > save1, save2;
bool ok = 0;

void check() {
    save1.clear();
    int mnr = INF, mnc = INF;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++) {
            if (c[i][j] == '#') {
                save1.push_back({i, j});
                mnr = min(mnr, i);
                mnc = min(mnc, j);
            }
        }
    for (int i = 0; i < save1.size(); i++) {
        save1[i].first -= mnr;
        save1[i].second -= mnc;
    }
    if (save1.size() != save2.size())return;
    for (auto it: save1) {
        if (!ma[it])return;
    }

    ok = 1;
}

void solve() {
    cin >> n;
    int mnr = INF, mnc = INF;
    for (int i = 1; i <= n; i++)for (int j = 1; j <= n; j++)cin >> a[i][j], c[i][j] = a[i][j];
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++) {
            cin >> b[i][j];
            if (b[i][j] == '#') {
                save2.push_back({i, j});
                mnr = min(mnr, i);
                mnc = min(mnc, j);//找到最左上角的那个#
            }
        }
    for (int i = 0; i < save2.size(); i++) {
        save2[i].first -= mnr;//将所有#向左上角移
        save2[i].second -= mnc;
        ma[save2[i]] = 1;
    }
    for (int u = 0; u < 4; u++) {
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++) {
                c[j][n - i + 1] = a[i][j];
            }
        for (int i = 1; i <= n; i++)for (int j = 1; j <= n; j++)a[i][j] = c[i][j];
        check();
    }

}

int main() {
    solve();
    if (ok)puts("Yes");
    else puts("No");
    return 0;
}

D - Rectangles

题意:

在二维平面上给n个坐标,求坐标能构成的所有平行于X,Y轴的矩形的数目.

题解:

以x坐标为基准,当y轴相等时,如果下一条边和这条边的长度、位置都相同,那就可以构成一个矩形.所以只需要枚举所有点,当两个点y坐标相同时记录下两点构成的线段的位置和长度,当下一次又出现同一位置和长度的线段时,就可以构成一个矩形… 以此类推.用一个map记录

代码:
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<unordered_map>
#include<set>
#pragma GCC optimize(2)
using namespace std;
#define ll long long
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define fi first
#define se second
#define pb push_back
#define debug(a) cout << #a << " " << a << '\n';
const int N=1e5+5;
const int M=1e5+5;
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const ll mod = 1e9 + 7;
inline ll read();
int n,m;
int a[205][205];
int b[205][205];
vector<PII>v;
map<pair<ll,double > ,ll>cnt;
int main(){
    //ios::sync_with_stdio(false);
    ll ans=0;
    cin>>n;
    for(int i=0;i<n;i++){
        int x,y;
        cin>>x>>y;
        v.pb({x,y});
    }

    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++) {
            if (v[i].se == v[j].se) {
                ll len = abs(v[i].fi - v[j].fi);
                double xx = (v[i].fi + v[j].fi) * 1.0 / 2.0;
                ans += cnt[{len, xx}];
                cnt[{len, xx}]++;
            }
        }
    }
    cout<<ans;

    return 0;
}


inline ll read() {
    char ch = getchar();
    ll p = 1, data = 0;
    while(ch < '0' || ch > '9') {
        if(ch == '-')p = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') {
        data = data * 10 + (ch ^ 48);
        ch = getchar();
    }
    return p * data;
}

E - Destruction

题意:

给一个无向图,让你从中选出几个边,要求选出的边权总和最大并且剩下的图要是一个连通图.

题解:

要选出的边权总和最大,那就是让剩下的连通图边权总和最小,我们可以很容易想到最小生成树.但直接跑最小生成树是不行的,因为它有负边权.而负边我们是肯定不会选的,所以我们只需要特判一下,只要我们在跑最小生成树只要碰到负边权我们就给把它放进图里.(这样虽然不是树了但可以保证我们得到正确的答案)

代码:
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;
#define ll long long
const int N = 200010, M = 200010, INF = 0x3f3f3f3f;

int n, m;
int p[N];

struct Edge {
    int a, b, w;

    bool operator<(const Edge &W) const //重载运算符以便于能直接sort
    {
        return w < W.w;
    }
} edges[M];

int find(int x) //并查集
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

ll kruskal() {
    sort(edges, edges + m);

    for (int i = 1; i <= n; i++) p[i] = i;    // 初始化并查集

    ll res = 0, cnt = 0;
    for (int i = 0; i < m; i++) {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;

        a = find(a), b = find(b);
        if (a != b)//找到的祖宗不相等说明不连通
        {
            p[a] = b;
            res += w;
            cnt++;
        }
        else {
            if (w < 0)res += w;
        }
    }

    return res;
}

int main() {
    ll sum = 0;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++) {
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w);
        edges[i] = {a, b, w};
        sum += w;
    }

    cout << sum - kruskal();


    return 0;
}

F - Blocked Roads

题意:

给定一个n个点,m条边的有向图,边权为1,对每个边i,求把这个边去掉的1-n的最短距离.

题解:

因为m最大是400399.所以不能直接枚举边bfs.但我们可以想到,对于1->n的最短路来说,最多应该只有n-1条边是有效的,所以我们可以先bfs求一遍正常的1->n的最短路,把有效的边标记出来.然后再枚举m条边,如果这条边没有被标记过,说明去不去掉它对1-n的最短距离没有影响,所以直接输出1-n的最短距离.否则,就再在原图上求一次去掉边i的bfs,时间复杂度是 O ( N ∗ ( N + M ) ) O_{(N*(N+M))} O(N∗(N+M))​

代码:
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<unordered_map>
#include<set>

#pragma GCC optimize(2)
using namespace std;
#define ll long long
#define PII pair<int,int>
#define PIII pair<pair<int,int>,int>
#define PLL pair<ll,ll>
#define fi first
#define se second
#define pb push_back
#define debug(a) cout << #a << " " << a << '\n';
const int N = 500;
const int M = 1e5 + 5;
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const ll mod = 1e9 + 7;

inline ll read();

int n, m;
vector<int> g[N*N];
int dis[N], dis2[N];
int pre[N];
bool st[N*N];
map<PII, int> mp;
map<int, PII > mp2;

void bfs() {
    memset(dis,-1,sizeof dis);
    queue<int> q;
    dis[1] = 0;
    q.push(1);
    while (!q.empty()) {
        int t = q.front();

        q.pop();
        for (int i = 0; i < g[t].size(); i++) {
            int j = g[t][i];
            if (dis[j]!=-1)continue;
            dis[j] = dis[t] + 1;
            pre[j] = t;
            //cout<<j<<' '<<t<<'\n';
            q.push(j);
        }
    }
}

void bfs2(int x, int y) {
    queue<int> q;
    dis2[1] = 0;
    q.push(1);
    while (!q.empty()) {
        int t = q.front();

        q.pop();
        for (int i = 0; i < g[t].size(); i++) {
            int j = g[t][i];
            if (t == x && j == y)continue;
            if (dis2[j] != -1)continue;
            dis2[j] = dis2[t] + 1;
            q.push(j);
        }
    }
}


int main() {
    //ios::sync_with_stdio(false);
    cin >> n >> m;
    for (int i = 1; i <= m; i++) {
        int a, b;
        cin >> a >> b;
        g[a].pb(b);
        mp[{a, b}] = i;
        mp2[i] = {a, b};
    }
    bfs();
    int now = n;
    while (true) {
        if (mp[{pre[now], now}]) {
            st[mp[{pre[now], now}]] = true;//标记有效边

        }
        now = pre[now];
        if (now == 1 || !now)break;
    }

    for (int i = 1; i <= m; i++) {
        if (!st[i])cout << dis[n] << '\n';
        else {
            memset(dis2, -1, sizeof dis2);
            int x = mp2[i].fi;
            int y = mp2[i].se;
            bfs2(x, y);

            cout << dis2[n] << '\n';
        }
    }

    return 0;
}


inline ll read() {
    char ch = getchar();
    ll p = 1, data = 0;
    while (ch < '0' || ch > '9') {
        if (ch == '-')p = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        data = data * 10 + (ch ^ 48);
        ch = getchar();
    }
    return p * data;
}
Reinhart_L
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AtCoder Beginner Contest 218
Code_Shark的博客
09-12 146
A. 简单判断 根据题义： S[N]=xS[N] = xS[N]=x，输出 NoNoNo S[N]=oS[N] = oS[N]=o，输出 YesYesYes #include<bits/stdc++.h> using namespace std; int main(void) { string s; int n; cin >> n >> s; if (s[n - 1] == 'x') cout << "No\n"; else cout &lt
AtcoderABC218（D~G）题解
最新发布
zswangziye的博客
07-08 217
遍历一遍树，维护当前路径上的中位数，这个离散化一下，用树状数组维护，二分查找中位数就行。把删边改为加边，问题转化为求加任意数量的边，使得最终图为连通图，最少能得到多少钱？时可以对未删边时的最短路上的边进行标记，如果没有删掉这些边，那答案是与第一次。所以先标记选择的最小生成树上的边，然后在剩下的边里选择，得到最大的钱数。首先想到的是暴力去做，但是这样的时间复杂度错了，因为边数最大的情况为。轴平行的边，然后暴力判断其中两条边能不能构成矩形。，又要是连通图，就是最小生成树。一定会选择子树中最大的那一个，小。
AtCoder Beginner Contest 218 C - Shapes
karshey的博客
09-11 263
C 一次原地和三次旋转，给我转麻了。记录一下。（但是写的很拉） #include<bits/stdc++.h> using namespace std; typedef long long ll; const int N=205; char s[N][N],t[N][N]; struct node { int x,y; }; int cmp1(node a,node b)//从左到右 从上到下 先y小 再x小 { if(a.y!=b.y) return a.y<b.y; else
AtCoder Beginner Contest 218（补题）
weixin_54699118的博客
09-13 326
C - Shapes 题意： 给定两个图，SSS和TTT，’#'代表图案，‘.’‘.’‘.’代表空，整幅图是N✖NN✖NN✖N的大小，现在问你，能否旋转90°和平移的操作(操作数不限)，来把S图中的图案，变成T中的图案 思路： 找到S图和T图中，图案的最左端、右端、上端、下端的坐标，上下左右坐标之外的地方说明都是空地，不用管，此时，此时，把新图(坐标是最左端右端上端下端之中的图)，通过旋转，会有4种情况，旋转0，90，180，270，把旋转出来的图，存下来，看T图中是否有上述4种情况之一的图，可以小优
题解：AtCoder Beginner Contest 265C - Belt Conveyor (atcoder.jp)
06-18
这篇题解是关于AtCoder Beginner Contest 265C题目——"Belt Conveyor"的解决方案。这是一道入门级别的算法问题，主要考察的是模拟和边界条件处理能力。在这个问题中，你需要模拟一个传送带系统，并根据给定的网格...
题解：AtCoder Beginner Contest 260 D-Changing Jewels
06-06
代码
题解：AtCoder Beginner Contest 262 C - Min Max Pair
06-14
代码，好简单。（请点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞...
题解：AtCoder Beginner Contest 261D - Flipping and Bonus
06-13
代码
题解：AtCoder Beginner Contest 260 E - At Least One
06-12
代码
AtCoder Beginner Contest 218 C - Shapes (模拟)
我们都有光明的未来
09-12 374
linkkkk 题意： 给两个n∗nn*nn∗n的矩阵，#\##表示物体所在位置，问111能否通过旋转90°90°90°和平移任意次得到222 思路： 啊大概就是暴力模拟判断一下，然后就没想好怎么模拟。 首先，如果两个矩阵的#个数不相等，一定是NoNoNo 然后，旋转90°90°90°任意次，其实只需要旋转444次就足够了。 平移的话，对于每次旋转后的图形，找到最左上的起点，然后判断其他点和这个点问位置关系。 代码： int n; int s[210][210],t[210][210]; int cnts=
AtCoder Beginner Contest 218 D Rectangles(思维)
weixin_45948940的博客
09-12 275
题面链接 题意：对于给出的N个点，询问能组成多少个矩形满足该矩形平行X轴和Y轴。 问题分析： 有一道类似的题，给出N个点求有多少个矩形。 首先考虑如何在N个点里面确定矩形，矩形由对角线长度和中心唯一确定，那么只需要枚举N2 计算两个点之间的对角线长度以及中心，就可以计算出所有的矩形数。 好，我们回过头来分析这个题，不难发现只需要以一个轴为平行即可，假设我们平行于X轴，那么枚举点的时候只需要处理Y一样的点，处理他们的距离和中心的X坐标，不难发现当且仅当存在其他的对角线长度相等且中心X也是 该pre_X
AtCoder题解 —— AtCoder Regular Contest 109 —— B - log —— 二分
努力中的老周的专栏
12-01 610
题目相关 题目链接 AtCoder Regular Contest 109 B 题，https://atcoder.jp/contests/arc109/tasks/arc109_b。 Problem Statement Snuke is visiting a shop in Tokyo called 109 to buy some logs. He wants n logs: one of length 1, one of length 2, ..., and one of length n. T
AtCoder 218: C: Shapes(判断两个图形是否一样)
qq_45772236的博客
09-18 407
题目：题目链接 分析： 可通过旋转和移动变换来判断由#组成的两个图形是否一直。 解析： 先寻找最左最上的一个点，记录下位置。 然后开始每一个#进行判断，偏移量是否相同。 然后旋转三次，共四次每次重复上面操作。 Input 1: 5 ..... ..#.. .###. ..... ..... ..... ..... ....# ...## ....# Output 1: Yes Input 2: 5 ##### ##..# #..## ##### ..... ##### #..## ##..# ####
AtCoder Beginner Contest 218 F - Blocked Roads （最短路径还原 思维）
我们都有光明的未来
09-12 303
linkk 题意： 给出点数为nnn，边数为mmm的有向图，问每次删去一条边时，1−n1-n1−n的最短路，每次询问相互独立。n<=400n<=400n<=400 思路： 如果要删去的边不在111到nnn的最短路上的话，那么不会对最短路造成影响。 如果在最短路上的话，就需要重新跑一遍最短路。 由于nnn只有400400400，时间复杂度为O(n∗(n+m))O(n*(n+m))O(n∗(n+m)) 具体操作为： 求出111到nnn的最短路resresres并且记录下最短路上的边。 对于m
AtCoder Beginner Contest 218 D：Rectangles
weixin_52045738的博客
09-18 213
题目背景： AtCoder Beginner Contest 218（taskC）： 问题描述： We have N distinct points on a two-dimensional plane, numbered 1,2,…,N. Point i (1≤i≤N) has the coordinates (xi,yi).How many rectangles are there whose vertices are among the given points and whose edges a
AtCoder Beginner Contest 218 F - Blocked Roads（MST+思维）
weixin_45948940的博客
09-12 193
题面链接 题意： 一个图里面，每条边有一个权值Ci ，现在删掉该边就可以得到Ci，但是最终要保证图联通，求最大的能收获的ΣCi 分析：首先可以考虑MST，但是这里又不完全是MST，因为比如一条边的两个点已经合并到了同一个father，但是边权为负，此时我们可以把它留下来，同理若已经构成了一个生成树，那么剩下的边可以任意拿或者不拿，只需要取正值边权即可。 struct node{ ll u,v,w; }a[manx]; ll f[manx]; bool cmp(node a,node b){
AtCoder Beginner Contest 218 题解
Eloi的Blog
09-12 457
个人博客：Eloi-还在前进. AtCoder Beginner Contest 218 题解： A: Weather Forecast B: qwerty C: Shapes D: Rectangles E: Destruction tags:最小生成树 题意：给一个连通无向带负权图，M条边。 你从中取边，每取一个边，按照边权是否大于零给reward或fine。 让你计算，在保证取完后图联通的前提下，能获得的最大reward。 思路： 先计算不考虑保证联通情况下最大reward和。 逆
atcoder beginner contest 218
03-16
atcoder beginner contest 218 是一场由 AtCoder 组织的初学者比赛，旨在为初学者提供一个锻炼自己编程能力的平台。比赛通常包括多个问题，参赛者需要在规定时间内完成这些问题的解答。这场比赛对于想要提高自己编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值