AtCoder Regular Contest 112 简单题解（AC 了 A ~ D，缺 E ~ F）

最新推荐文章于 2024-06-01 09:35:03 发布
最新推荐文章于 2024-06-01 09:35:03 发布
阅读量982 收藏 1
点赞数
分类专栏： OJ题解 # AtCoder题解 文章标签： AtCoder题解 ARC112
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/justidle/article/details/113804629
版权

A 题：A - B = C

题目链接

https://atcoder.jp/contests/arc112/tasks/arc112_a。

题解

本题不难，如果数据量不大的话，本题可以使用暴力枚举的方法来解决。也就是在 [L, R] 之间枚举 A 和 B，并计算 C=A-B，这样算法的时间复杂度是 O(N^2) 的。

我们看看本题的数据范围，本题给了 T 个样例，T 的最大值是 2e4。[L, R] 的最大值是 1e6。如果我们进行暴力枚举的话，计算量将达到 2*10^4*10^6=2*10^{10}，这样的计算量，我们肯定是没有办法在 1 秒内完成的。为了完成这个任务，本题需要一个 O(1) 的算法，也就是说，根据给定的 [L, R] 计算出对应的三元组。这样本题的时间复杂度将变为 O(T)。因此本题变为一个纯粹的数学题。

本题是要求在 [L, R] 的范围内，找出所有的三元组 {A, B, C}，这三元组满足两个条件：

1、A, B, C \in [L, R]。

2、C=A-B。

根据上面两个条件，我们可以写出满足的三元组个数为：\frac{(r-2*l+1)*(r-2*l+2)}{2} \quad \forall \quad 2*l \leq r。这个计算结果不难，自己推导一下。

数据范围分析

根据题目提供的数据范围，很明显需要使用 long long。

AC 参考代码

#include <iostream>
using namespace std;
typedef long long ll;
int main() {
   int t;
   cin>>t;
   while (t--) {
      ll l,r;
      cin>>l>>r;
 
      ll ans=0;
      if (r>=2*l) {
         ans+=(r-2*l+1)*(r-2*l+2)/2;
      }
      cout<<ans<<"\n";
   }
   return 0;
}

B题：B - -- - B

题目链接

https://atcoder.jp/contests/arc112/tasks/arc112_b。

题解

如果数据量小，本题可以使用 BFS 来完成。但是本题数据范围，C 最大为 1e18，看到这个数据，不需要过多解释，BFS 一定是 TLE。因此本题需要一个 O(1) 时间复杂度。这样本题又又变成了一个数学题。找规律。

具体看 AC 代码吧。不想写太多。

数据范围分析

没什么特别解释。long long 走起。

AC 参考代码

#include <iostream>
using namespace std;
typedef long long ll;
int main(){
    ll b,c;
    cin>>b>>c;
    //特例处理
    if (1==c){
        if (b) {
            cout<<"2\n";
        } else {
            cout<<"1\n";
        }
        return 0;
    }

    ll lx,ly,rx,ry;
    lx=b-c/2;
    rx=b+c/2-1;
    ly=-b-(c-1)/2;
    ry=-b+(c-1)/2;

    if (rx<ly||ry<lx){
        cout<<rx-lx+ry-ly+2<<"\n";
        return 0;
    }
    if (rx<ry) {
        rx=ry;
    }
    if (ly<lx) {
        lx=ly;
    }
    cout<<rx-lx+1<<"\n";

    return 0;
}

C题：C - DFS Game

题目链接

https://atcoder.jp/contests/arc112/tasks/arc112_c。

题解

都直接告诉你了，我们快乐的 DFS 吧。

数据范围分析

n 的最大值为 1e5，v 的范围是 [1, n]，用 int 够了。

AC 参考代码

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int MAXN=1e5+4;
int fir[MAXN],nex[MAXN],to[MAXN],f[MAXN],sz[MAXN],tot;
struct node{
   int x,id;
   bool operator<(const node &i) const{
      return x>i.x;
   }
}st[MAXN];

void add(int u,int v) {
   nex[++tot]=fir[u];
   fir[u]=tot;
   to[tot]=v;
}

void dfs(int u) {
   int s1=0,s2=0,top=0;
   sz[u]=f[u]=1;
   for (int i=fir[u];i;i=nex[i]) {
      dfs(to[i]);
   }
   for (int i=fir[u];i;i=nex[i]) {
      sz[u]+=sz[to[i]];
      if (sz[to[i]]-f[to[i]]>=f[to[i]]&&(sz[to[i]]&1)==0) {
         f[u]+=f[to[i]];
      } else {
         if (sz[to[i]]&1) {
            st[++top]=(node){sz[to[i]]-f[to[i]]*2,to[i]};
         } else {
            s1+=f[to[i]];
            s2+=sz[to[i]]-f[to[i]];
         }
      }
   }
   sort(st+1,st+1+top);
   for (int i=1;i<=top;++i) {
      if (i&1) {
         f[u]+=f[st[i].id];
      } else {
         f[u]+=sz[st[i].id]-f[st[i].id];
      }
   }
   if (top&1) {
      f[u]+=s2;
   } else {
      f[u]+=s1;
   }
}

int main() {
   int n, u;
   cin>>n;
   for(int i=2;i<=n;++i) {
      cin>>u;
      add(u,i);
   }
   dfs(1);
   cout<<f[1]<<"\n";
   return 0;
}

D题：D - Skate

题目链接

https://atcoder.jp/contests/arc112/tasks/arc112_d。

题解

不就是一个数据结构的并查集（DSU）问题。我们只需要根据题意建立 DSU 关系，然后再行遍历、列遍历 DSU 关系即可。

DSU 方面的，可以参考一下 AtCoder 在 Github 上提供的 AC-library 这个库，对应的 Github 链接为：https://github.com/atcoder/ac-library。

考虑到国内 Github 的速度，下面是 DSU 的源码。

#ifndef ATCODER_DSU_HPP
#define ATCODER_DSU_HPP 1

#include <algorithm>
#include <cassert>
#include <vector>

namespace atcoder {

// Implement (union by size) + (path compression)
// Reference:
// Zvi Galil and Giuseppe F. Italiano,
// Data structures and algorithms for disjoint set union problems
struct dsu {
  public:
    dsu() : _n(0) {}
    explicit dsu(int n) : _n(n), parent_or_size(n, -1) {}

    int merge(int a, int b) {
        assert(0 <= a && a < _n);
        assert(0 <= b && b < _n);
        int x = leader(a), y = leader(b);
        if (x == y) return x;
        if (-parent_or_size[x] < -parent_or_size[y]) std::swap(x, y);
        parent_or_size[x] += parent_or_size[y];
        parent_or_size[y] = x;
        return x;
    }

    bool same(int a, int b) {
        assert(0 <= a && a < _n);
        assert(0 <= b && b < _n);
        return leader(a) == leader(b);
    }

    int leader(int a) {
        assert(0 <= a && a < _n);
        if (parent_or_size[a] < 0) return a;
        return parent_or_size[a] = leader(parent_or_size[a]);
    }

    int size(int a) {
        assert(0 <= a && a < _n);
        return -parent_or_size[leader(a)];
    }

    std::vector<std::vector<int>> groups() {
        std::vector<int> leader_buf(_n), group_size(_n);
        for (int i = 0; i < _n; i++) {
            leader_buf[i] = leader(i);
            group_size[leader_buf[i]]++;
        }
        std::vector<std::vector<int>> result(_n);
        for (int i = 0; i < _n; i++) {
            result[i].reserve(group_size[i]);
        }
        for (int i = 0; i < _n; i++) {
            result[leader_buf[i]].push_back(i);
        }
        result.erase(
            std::remove_if(result.begin(), result.end(),
                           [&](const std::vector<int>& v) { return v.empty(); }),
            result.end());
        return result;
    }

  private:
    int _n;
    // root node: -1 * component size
    // otherwise: parent
    std::vector<int> parent_or_size;
};

}  // namespace atcoder

#endif  // ATCODER_DSU_HPP

AC 参考代码

#include <iostream>
#include <algorithm>
#include <cassert>
#include <vector>
#include <unordered_set>

namespace atcoder {

// Implement (union by size) + (path compression)
// Reference:
// Zvi Galil and Giuseppe F. Italiano,
// Data structures and algorithms for disjoint set union problems
struct dsu {
  public:
    dsu() : _n(0) {}
    explicit dsu(int n) : _n(n), parent_or_size(n, -1) {}

    int merge(int a, int b) {
        assert(0 <= a && a < _n);
        assert(0 <= b && b < _n);
        int x = leader(a), y = leader(b);
        if (x == y) return x;
        if (-parent_or_size[x] < -parent_or_size[y]) std::swap(x, y);
        parent_or_size[x] += parent_or_size[y];
        parent_or_size[y] = x;
        return x;
    }

    bool same(int a, int b) {
        assert(0 <= a && a < _n);
        assert(0 <= b && b < _n);
        return leader(a) == leader(b);
    }

    int leader(int a) {
        assert(0 <= a && a < _n);
        if (parent_or_size[a] < 0) return a;
        return parent_or_size[a] = leader(parent_or_size[a]);
    }

    int size(int a) {
        assert(0 <= a && a < _n);
        return -parent_or_size[leader(a)];
    }

    std::vector<std::vector<int>> groups() {
        std::vector<int> leader_buf(_n), group_size(_n);
        for (int i = 0; i < _n; i++) {
            leader_buf[i] = leader(i);
            group_size[leader_buf[i]]++;
        }
        std::vector<std::vector<int>> result(_n);
        for (int i = 0; i < _n; i++) {
            result[i].reserve(group_size[i]);
        }
        for (int i = 0; i < _n; i++) {
            result[leader_buf[i]].push_back(i);
        }
        result.erase(
            std::remove_if(result.begin(), result.end(),
                           [&](const std::vector<int>& v) { return v.empty(); }),
            result.end());
        return result;
    }

  private:
    int _n;
    // root node: -1 * component size
    // otherwise: parent
    std::vector<int> parent_or_size;
};

}  // namespace atcoder

using namespace std;
using namespace atcoder;

int main() {
   int h, w;
   cin >> h >> w;
   vector<string> s(h);
   for (int i=0; i<h; i++) {
      cin >> s[i];
   }
   //增加边界条件
   s[0][0] = s[0][w - 1] = s[h - 1][0] = s[h - 1][w - 1] = '#';

   //初始化DSU
   dsu d(h + w);
   //建立DSU关系
   for (int r = 0; r < h; ++r) {
      for (int c = 0; c < w; ++c) {
         if (s[r][c] == '#') {
            d.merge(r, h + c);
         }
      }
   }

   //遍历DSU
   unordered_set<int> row, col;
   //行遍历
   for (int r = 0; r < h; ++r) {
      row.insert(d.leader(r));
   }
   //列遍历
   for (int c = 0; c < w; ++c) {
      col.insert(d.leader(h + c));
   }

   cout << min(row.size() - 1, col.size() - 1) << "\n";

   return 0;
}

 

努力的老周
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
AtCoderLibraryForJava
05-06
Java的AtCoder库 集合具有与相同的功能的Java库集合与原始ACL不同，它没有合并到代码测试环境中，因此您可以复制和粘贴它到您的代码中，请使用。 截至2020年9月12日，已移植了ACL中实现的所有功能。 中国剩余定理 下限总和 （注意：对于原始家庭中实现的pow_mod和inv_mod ，请使用ModInt） 后缀数组 最长的公共前缀数组 Z算法 我们还根据需要在ACL之外实现算法。 高速输入/输出 多集 对于那些想要编辑程序的人 我们鼓励您加入Slack工作区，并使用它共享每个编辑器的进度，以防止重复（此说明不会阻止您改进已实现的功能。）加入我们，如果需要，请联系Yoichi。茄子（Twitter） 。 牌照等 我决定采用CC0许可证。
AtCoder Regular Contest 102 Task C 题解（含代码）
01-16
【内测版】思维专项 1.0 Task O 一句话题解 by LJ24TangHaoLong「唐浩滝」 题面： 求a, b, c不大于n且满足a+b, b+c, a+c为k倍数的三元组(a, b, c)的个数 原题： AtCoder Regular Contest 102 Task C
AtCoder Regular Contest 112 Summary
linweitong2020的博客
02-18 226
AtCoder Regular Contest 112 Summary A - B = C：统计+数学 考虑固定CCC，即A=B+CA=B+CA=B+C。 ∵A=B+C≤R,∴L≤B≤R−C.∴L≤C≤R−L. \because A=B+C\leq R,\\ \therefore L\leq B\leq R-C.\\ \therefore L\leq C\leq R-L.\\ ∵A=B+C≤R,∴L≤B≤R−C.∴L≤C≤R−L. 答案就为∑i=LR−LR−i−L+1\sum_{i=L}^{R-L}{R-i
探索 Rust 领域的竞技编程利器：ac-library-rs
最新发布
gitblog_00002的博客
06-01 234
???? 探索 Rust 领域的竞技编程利器：ac-library-rs 项目地址:https://gitcode.com/rust-lang-ja/ac-library-rs 在竞技编程的世界里，速度与准确性是生存的法则。今天，我们要向您推荐一个为 Rust 社区量身定做的强大工具——ac-library-rs，这是 AtCoder Library 的 Rust 版本，专为那些在算法竞赛中追求极致效率...
AtCoder Regular Contest 112 B 思维 数轴区间去重
QiuHong 的博客
03-06 204
AtCoder Regular Contest 112 B 题目链接 官方题解 Solution 考虑刚刚好使用 CCC 元 当钱数为 CCC 时，考虑这样一个特殊序列，对数 BBB 做任意次减一操作之后，在乘上 −1-1−1 的结果 如果我们乘上奇数次 −1-1−1 ，最终每一次减法都会在 BBB 上造成加 111 的贡献 如果我们乘上偶数次 −1-1−1 ，最终每一次减法都会在 BBB 上造成减 111 的贡献 当钱数 CCC 为奇数时，可以将 CCC 表示为 C=2n+1C=2n+1C=2n+1
AtCoder Regular Contest 112
ANTFANAAA的博客
02-15 415
AtCoder Regular Contest 112 比赛链接 官方Editorial A.B = C 找规律，可以发现 ①当l>r/2l > r / 2l>r/2就一定为0个。 ②l==rl == rl==r的时候，除了0 0这一组是1，其他都是0。 ③其余情况，写几个例子可以发现，其实就是一个d=1d=1d=1的等差数列求和。 #define int long long signed main() { //freopen("in.txt","r",stdin); //fr
AtCoder Regular Contest 112 A题A-B = C
浅蓝色の伤的博客
08-11 160
A - B = C AtCoder - arc112_a 这是个找规律的题目。 给出l 和r ，求满足A - B == C 的ABC有多少对； 其中A，B，C，均在[ l, r ]中； 当 l * 2 > r 时, 则答案必为0； 当 l * 2 == r 时，则答案为1，即A= r，B = C = r 时； 当 l * 2 < r 时，可发现，答案从2 * l 到 r 的差为1的等差数列的和 等差数列求和公式 我的代码 #include<bits/stdc++.h> u
AtCoder Beginner Contest 166 A ~~E
01-03
A 水题： #include using namespace std; int main(){ string s; cin>>s; if(s==ABC) cout<<ARC>>n>>k; int d; for(int i=
题解：AtCoder Beginner Contest 265 E - Warp (atcoder.jp)
06-19
代码
题解：AtCoder Beginner Contest 260 E - At Least One
06-12
代码
题解：AtCoder Beginner Contest 260 D-Changing Jewels
06-06
代码
AtCoder_Library:AtCoderのPythonのライブラリ
03-06
テンプレ import bisect , copy , heapq , math , sys from collections import * from functools import lru_cache from itertools import accumulate , combinations , permutations , product def input (): return sys . stdin . readline ()[: - 1 ] def ruiseki ( lst ): return [ 0 ] + list ( accumulate ( lst )) def celi ( a , b ): return - ( - a // b ) sys . setrecursionlimit ( 5000000 ) mod = pow ( 10
ac-library:AtCoder库
03-17
AC（AtCoder）库 AC Library是的官方图书馆。 该存储库管理AC库的内容。 您可以参考以下链接以获取更多详细信息： master分支的文档如下： 政策 我们这个项目的目标是实现 每个AtCoder用户都可以在学习PC方面花费最少的精力来使用此库 在竞争性编程中使用的最大方便。 我们完全忽略其他用法。 没有错误。 这是一个幻想，但是我们追求这一点。 通过此策略，我们有意忽略了某些C ++方式。 例如， 我们不使用size_t ，而是使用int 。 segtree处理函数指针，而不处理函数对象。 等等... 项目方向 由于存在优缺点，因此我们尚未决定是否应增加该库的内容。 如果您对此主题感兴趣，请加入《的讨论。 目前，我们不打算添加新功能，并且我们仅将此存储库用于 收集问题 记录变更日志 对我们的发行版进行版本控制 贡献 我们仅接受AtCoder用户的问题/
atcoder-library-swift:AtCoder库（ACL）的快速端口
03-15
atcoder-library-swift ac-library-swift是AtCoder库（ACL）的Swift端口。 有关ACL，请参见下文。 进步 卷积 su 芬威克特里 懒人树 数学 最大流量 最小成本流 莫丁 scc 赛格特里 细绳 双重卫星 如何贡献 开始工作之前，请先创建问题或PR草案。 进行PR并通过测试。 执照 Sources文件夹中的头文件是根据许可证获得许可的。
R&A Library v2.03 (控件包)
08-07
R&A Library v2.03，一套纯Delphi组件含完整代码，具体组件察看Readme.txt
atcoder-cli：AtCoder命令行工具
01-29
atcoder-cli 命令行工具 获取比赛信息 创建比赛项目目录使用自定义模板自动配置 与 提交没有指定网址的代码 自动下载样本输入/输出 要求 node.js （可选，但推荐） 安装 $ npm install -g atcoder-cli 用法 $ acc login # login your atcoder account $ acc session # check login status $ # your login session will be saved to a local file, but your password won't be saved $ # to delete the session file, use `acc logout` $ acc new abc001 # "abc001/" directory will be created $ cd abc001/ $ acc contest # show the contest information $ acc tasks # show task list $ acc add $ cd a/ $
AtCoder Regular Contest 112 D 并查集dsu
QiuHong 的博客
03-08 339
AtCoder Regular Contest 112 D Solution 官方题解 原题链接 不难发现，对于所有的格子，只要它是一个有效格子，那么它们就可以到达 (1,1)(1,1)(1,1) 这个格子。因此我们可以反过来看这个问题，如果所有从 (1,1)(1,1)(1,1) 出发的旅行者都能到达所有格子，那么这张图就是一个有效图。 因为有墙面的存在，我们有以下结论 1−st1-st1−st 行是有效的 ⟺ 1−st1-st1−st 列是有效的 1−st1-st1−st 行是有效的 ⟺ W−thW-t
AtCoder Regular Contest 112 题解
bogedaye的博客
11-01 201
A. A - B = C A题题目链接 【题解】题意要求符合题意的对数。我们考虑对于每一个C而言，有如下的对数：(L, L + C), … ,（R - C, R), 即总共R - L + 1 - C对。而L <= C <= R 且 C <= R - L(如果C > R - L则没有符合题意的对数)，则 L <= C <= R - L，但是显然L, R - L谁大谁小是不清楚的，需要讨论情况。如果L > R - L，则没有符合题意的对数，输出为0；否则即存在若干个C,
-- - B（AtCoder - arc112_b）
Gverzh的博客
09-09 177
– - B（AtCoder - arc112_b） 链接： VJ链接https://vjudge.ppsucxtt.cn/problem/AtCoder-arc112_b 原链接：https://atcoder.jp/contests/arc112/tasks/arc112_b 题意： 数B 在花费<=C元时 最多能走到的数的个数 花费1元 B 走到 -B 花费2元 B 走到 B-1 规律 画出图来会比较好想 C足够大时，只需要考虑左边界与右边界，中间的数都能走到 只需要讨论 C正好满足 B 走到
AtCoder Beginner Contest 134 简要题解
05-23
AtCoder Beginner Contest 134 是一场 AtCoder 的入门级比赛，以下是每道题的简要题解： A - Dodecagon 题目描述：已知一个正十二边形的边长，求它的面积。 解题思路：正十二边形的内角为 $150^\circ$，因此可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

努力的老周

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值