AtCoder Beginner Contest 340（A-G）

最新推荐文章于 2024-11-14 16:38:00 发布
最新推荐文章于 2024-11-14 16:38:00 发布
阅读量413 收藏 3
点赞数 4
分类专栏： 动态规划 数据结构 Atcoder 文章标签： 数据结构 c++ 动态规划 图论
kkk
本文链接：https://blog.csdn.net/scanner___yw/article/details/136103261
版权
本文解析了AtCoder编程平台上的五道题目，涉及循环输出、动态规划、模拟操作、记忆化搜索、树状数组等技术，展示了在解决这些数学和算法问题时的具体思路和代码实现。
摘要由CSDN通过智能技术生成

A - Arithmetic Progression (atcoder.jp)

        1.思路：循环输出即可

        2.代码：

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
void solve()
{
    int a,b,c;
    cin >> a >> b >> c;
    while (a <= b) {
        cout << a << ' ';
        a += c;
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    while(T --) solve();
    return 0;
}

B - Append (atcoder.jp)

        1.思路：vector模拟即可。

        2.代码：

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
void solve()
{
    vector<int> v;
    int q;
    cin >> q;
    while (q --) {
        int op,x;
        cin >> op >> x;
        if (op == 1) {
            v.pb(x);
        }
        else {
            cout << v[v.size() - x] << '\n';
        }
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    while(T --) solve();
    return 0;
}

C - Divide and Divide (atcoder.jp)

        1.思路：记忆化搜索，模拟即可。

        2.代码：

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
map<ll,ll> mem;
ll dfs(ll x)
{
    if (x == 1) {
        return 1ll;
    }
    if (mem.count(x)) {
        return mem[x];
    }
    return mem[x] = (dfs(x / 2) + dfs((x + 1) / 2)) + x;
}
void solve()
{
    ll n;
    cin >> n;
    cout << dfs(n / 2) + dfs((n + 1) / 2) << '\n';
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    while(T --) solve();
    return 0;
}

D - Super Takahashi Bros. (atcoder.jp)

        1.思路：发现每行给出的实际上可以等价于两条边

                        一条是i-->i + 1 花费a

                        一条是i-->c 花费b

        2.代码：

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
//从0开始
template<typename T>
class Graph {
    using pli = pair<T,int>;
private:
    const int n;
    vector<vector<pair<int,int>>> g;
public:
    Graph(int _n): n(_n) {
        g.resize(n);
    }

    void addEdge(int x,int y,int z = 0) {
        g[x].push_back({y,z});
    }

    vector<T> shortestPath(int s) {
        vector<T> dis(n);
        memset(dis.data(),0x3f,dis.size() * sizeof(T));
        priority_queue<pli,vector<pli>,greater<pli>> q;
        q.push({0,s});
        dis[s] = 0;
        while(!q.empty()) {
            auto [val,ver] = q.top();
            q.pop();
            if(val != dis[ver]) {
                continue;
            }
            for(auto &[y,w]: g[ver]) {
                if(dis[y] > val + w) {
                    dis[y] = val + w;
                    q.push({dis[y],y});
                }
            }
        }
        return dis;
    }
};
void solve()
{
    int n;
    cin >> n;
    Graph<ll> g(n);
    for (int i = 1;i < n;i ++) {
        int a,b,c;
        cin >> a >> b >> c;
        g.addEdge(i - 1,i,a);
        g.addEdge(i - 1,c - 1,b);        
    }
    auto p = g.shortestPath(0);
    cout << p[n - 1];
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    while(T --) solve();
    return 0;
}

E - Mancala 2 (atcoder.jp)

        1.思路：按照模拟的过程可以分为三段去操作，从当前位置到末尾+轮多少圈+剩下的次数。

                        发现这是一个需要维护区间加和单点查询的数据结构题目，因此我们考虑直接用树状数组维护原数组差分即可。或者直接用线段树维护原数组也行。

        2.代码：

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
template <typename T>
struct Fenwick {
    const int n;
    std::vector<T> a;

    Fenwick (int n) : n(n), a(n + 1) {}

    void add(int pos, T x) {
        for (int i = pos; i <= n; i += i & -i) {
            a[i] += x;
        }
    }

    T query(int x) {
        T res = 0;
        for (int i = x; i; i -= i & -i) {
            res += a[i];
        }
        return res;
    }

    T query(int l, int r) {
        if (l == 0 || l > r) {
            return 0;
        }
        return query(r) - query(l - 1);
    }

    //找到大于k得第一个地方
    T kth(int k) {
        int pos = 0;
        for(int j = 31 - __builtin_clz(n);j >= 0;j --) {
            if(pos + (1 << j) <= n && k > a[pos + (1 << j)]) {
                pos += 1 << j;
                k -= a[pos];
            }
        }
        return pos + 1;
    }
};
void solve()
{
    int n,q;
    cin >> n >> q;
    Fenwick<ll> fen(n);
    int pre = 0,x;
    for (int i = 1;i <= n;i ++) {
        cin >> x;
        fen.add(i,x - pre);
        pre = x;
    }
    for (int i = 1;i <= q;i ++) {
        cin >> x;
        x ++;
        ll rs = fen.query(x);
        ll mi = min(rs,0ll + n - x);
        fen.add(x,-rs);
        fen.add(x + 1,rs);
        if (mi) {
            rs -= mi;
            fen.add(x + 1,1);
            fen.add(x + 1 + mi,-1);
        }
        if (rs) {
            ll cz = rs / n,cm = rs % n;
            fen.add(1,cz);
            fen.add(1,1);
            fen.add(1 + cm,-1);
        }
    }
    for (int i = 1;i <= n;i ++) {
        cout << fen.query(i) << ' ';
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    while(T --) solve();
    return 0;
}

F - S = 1 (atcoder.jp)

        1.思路：考虑使用鞋带公式化简，我们可以得到，这么个方程|ay - bx| = 2，考虑把绝对值拆开，做两次exgcd求解即可。

        2.代码：

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
ll exgcd(ll a, ll b, ll &x, ll &y)
{
    if (!b)
    {
        x = 1, y = 0;
        return a;
    }
    ll d = exgcd(b, a % b, y, x);
    y -= a / b * x;
    return d;
}
void solve()
{
    ll a,b;
    cin >> a >> b;
    ll x,y;
    ll d1 = exgcd(a,-b,y,x);
    if (2 % d1) {
        ll d2 = exgcd(b,-a,x,y);
        x *= 2 / d2,y *= 2 / d2;
        if (2 % d2) {
            cout << -1 << endl;
        }
        else {
            cout << x << ' ' << y << '\n';
        }
    }
    else {
        x *= 2 / d1,y *= 2 / d1;
        cout << x << ' ' << y << '\n';
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    while(T --) solve();
    return 0;
}

G - Leaf Color (atcoder.jp)

        1.思路：考虑每个遍历每个颜色单独求一遍答案，因此可以建一棵虚树进行dp即可。

                f[i] 表示以i为根节点，（不管符不符合的答案为多少），g[i]表示\sum_{j \epsilon son[i]}f[j]。

                当i为枚举的颜色时，答案加上f[i]的方案数即可。

                当i不是枚举的颜色时，首先f[i]应该-1（因为i不能作为根节点），其次答案应该加上f[i] - g[i]（所有选择一个子树的方案和）。

        2.代码：

#include <bits/stdc++.h>
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 2e5 + 10;
using i64 = long long;

constexpr int P = 998244353;
// assume -P <= x < 2P
int Vnorm(int x) {
    if (x < 0) {
        x += P;
    }
    if (x >= P) {
        x -= P;
    }
    return x;
}
template<class T>
T power(T a, i64 b) {
    T res = 1;
    for (; b; b /= 2, a *= a) {
        if (b % 2) {
            res *= a;
        }
    }
    return res;
}
struct Mint {
    int x;
    Mint(int x = 0) : x(Vnorm(x)) {}
    Mint(i64 x) : x(Vnorm(x % P)) {}
    int val() const {
        return x;
    }
    Mint operator-() const {
        return Mint(Vnorm(P - x));
    }
    Mint inv() const {
        assert(x != 0);
        return power(*this, P - 2);
    }
    Mint &operator*=(const Mint &rhs) {
        x = i64(x) * rhs.x % P;
        return *this;
    }
    Mint &operator+=(const Mint &rhs) {
        x = Vnorm(x + rhs.x);
        return *this;
    }
    Mint &operator-=(const Mint &rhs) {
        x = Vnorm(x - rhs.x);
        return *this;
    }
    Mint &operator/=(const Mint &rhs) {
        return *this *= rhs.inv();
    }
    friend Mint operator*(const Mint &lhs, const Mint &rhs) {
        Mint res = lhs;
        res *= rhs;
        return res;
    }
    friend Mint operator+(const Mint &lhs, const Mint &rhs) {
        Mint res = lhs;
        res += rhs;
        return res;
    }
    friend Mint operator-(const Mint &lhs, const Mint &rhs) {
        Mint res = lhs;
        res -= rhs;
        return res;
    }
    friend Mint operator/(const Mint &lhs, const Mint &rhs) {
        Mint res = lhs;
        res /= rhs;
        return res;
    }
    friend std::istream &operator>>(std::istream &is, Mint &a) {
        i64 v;
        is >> v;
        a = Mint(v);
        return is;
    }
    friend std::ostream &operator<<(std::ostream &os, const Mint &a) {
        return os << a.val();
    }
};
vector<int> son[N],g[N];
int c[N],dep[N],dfn[N],fa[N][20],stk[N],top,tim;
inline void dfs(int u,int f)
{
    dfn[u] = ++ tim;
    dep[u] = dep[f] + 1;
    fa[u][0] = f;
    for(int i = 1;i <= 18;i ++) fa[u][i] = fa[fa[u][i - 1]][i - 1];
    for(auto v : g[u]) {
        if(v == f) continue;
        dfs(v,u);
    }
}
inline int LCA(int x,int y)
{
    if(dep[x] > dep[y]) swap(x,y);
    int d = dep[y] - dep[x];
    for(int i = 18;i >= 0;i --) {
        if(d >> i & 1) y = fa[y][i];
    }
    if(x == y) return x;
    for(int i = 18;i >= 0;i --) {
        if(fa[x][i] != fa[y][i]) {
            x = fa[x][i];
            y = fa[y][i];
        }
    }
    return fa[x][0];
}
Mint ans = 0;
int tarc = 0;
void add(int &a,int &b)
{
    son[a].push_back(b);
}
Mint DP(int x)
{
    Mint f = 1,g = 0;
    for (auto &y: son[x]) {
        auto nf = DP(y);
        f *= (nf + 1);
        g += nf;
    }
    if (c[x] == tarc) {
        ans += f;
    }
    else {
        f -= 1;
        ans += f - g;
    }
    son[x].clear();
    return f;
}
void buildTree(vector<int> &ver)
{
    if (ver.size() == 1) {
        ans += 1;
        return;
    }
    sort(ver.begin(),ver.end(),[&](int &x,int &y){
        return dfn[x] < dfn[y];
    });
    stk[top = 1] = 1;
    if (ver[0] != 1) {
        stk[++ top] = ver[0];
    }
    for (int i = 1;i < ver.size();i ++) {
        int lca = LCA(ver[i],stk[top]);
        while (top > 1 && dfn[stk[top - 1]] >= dfn[lca]) {
            add(stk[top - 1],stk[top]);
            top --;
        }
        if (lca != stk[top]) {
            add(lca,stk[top]);
            stk[top] = lca;
        }
        stk[++ top] = ver[i];
    }
    while (top) {
        add(stk[top - 1],stk[top]);
        top --;
    }
    DP(1);
}
vector<int> cor[N];
void solve()
{
    int n;
    cin >> n;
    for (int i = 1;i <= n;i ++) {
        cin >> c[i];
        cor[c[i]].push_back(i);
    }
    for (int i = 1;i < n;i ++) {
        int a,b;
        cin >> a >> b;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    dfs(1,0);
    for (int i = 1;i <= n;i ++) {
        if (cor[i].size()) {
            tarc = i;
            buildTree(cor[i]);
        }
    }
    cout << ans;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    while(T --) solve();
    return 0;
}

A real Warrior
关注
专栏目录
AtCoder Beginner Contest 263D - Left Right Operation
06-16
代码
D - Yet Another Recursive Function(记忆化搜索)[ AtCoder Beginner Contest 275]
m0_60593173的博客
11-15 250
0≤N≤1018数据范围很大所以不可能从前到后递推得到答案。
AtCoder Beginner Contest 184----D - increment of coins（记忆化搜索）
0k-ok
11-23 146
你是我可爱的诱惑，温柔的牵绊，无法割舍的存在。你说青涩最搭初恋，我们有相遇的时间，在风暖月光的地点，海之角也不再遥远。你我之间，看不见的宣言，一直都在，重复过很多年。 题解：f[i][j][k]表示金银铜币分别由i,j,k个时操作完成次数的期望值为f[i]j[j][k],不确定递推的顺序，所以采取记忆化搜索的形式。 #include <iostream> #include <cstdio> #include <algorithm> #include &lt.
AtCoder Beginner Contest 231 E 贪心 DFS 记忆化搜索
从你的全世界路过
12-12 408
题目 有N种货币，每种对应ai元，a1一定等于1，且ai-1一定是ai的倍数。 求出完成一笔X元的交易所需的最小货币数。 即支付钱加找钱所需的货币数加起来最小。 题解思路 贪心策略 用这个付完，即不找零。 要么用这个多付钱（前提是本来有多，否则就是白费的搜索）然后求最小的找零数。 在这两种情况中取min 因为a是从1开始的，所以必然能取到数。 这题复杂度一言难尽，居然能这么暴力。 AC代码 #include <bits/stdc++.h> //#include <unordered_map
汇编的段内、段间转移
weixin_622464的博客
12-14 4495
1、段内转移：只修改IP； 短转移：ip修改范围：-128-127 ，格式：jmp short 标号 近转移：ip修改范围：-32768-32767，格式：jmp near ptr 标号 直接转移的形式是： jmp near ptr 标号 间接转移的形式是： jmp word ptr 寄存器或内存单元 2、段间转移：同时修改CS、IP；又叫远转移。 直接转移的形式是： jmp far ptr 标号 间接转移的形式是： jmp dword ptr 内存单元 3、无条件转移：jmp 4、条件转移：jcxz；所
题解：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
代码
【数据结构】C语言二叉树中求度为2的结点的个数、交换二叉树的左右子树、二叉树中先序输出各结点及其层次
samroom的博客
11-11 605
编写算法，在以二叉链表存储的二叉树中，按先序次序输出各结点的内容及相应的层次数，要求以二元组的形式输出。（输出格式参见样例）编写算法，在以二叉链表存储的二叉树中，交换二叉树各结点的左右子树。编写算法，在以二叉链表存储的二叉树中，求度为2的结点的个数。
SystemVerilog学习笔记（八）：循环
qq_38156104的博客
11-11 956
循环只不过是将需要多次运行的语句包含在循环中，而不是重复编写这些语句。循环将根据条件语句运行多次，如果条件始终为真，则它会变成无限循环，系统将挂起。
【数据结构】实验二 单链表的基本操作
drt_0506的博客
11-14 264
1）根据输入的一系列整数，以0标志结束，用头插法建立单链表，并输出单链表中各元素值，观察输入的内容与输出的内容是否一致。4）在单链表中查找第i个元素，如果查找成功，则显示该元素的值，否则显示该元素不存在。2）在单链表的第i个元素之前插入一个值为x的元素，并输出插入后的单链表中各元素值。3）删除单链表中第i个元素，并输出删除后的单链表中各元素值。掌握链表基本操作的算法实现，以及对相应算法的性能分析。掌握线性表的链式存储结构的表示和实现方法。
数据结构-查找以及效率分析
dametime_的博客
11-11 304
将被查概率高的放到靠前位置,可以提高查找成功的效率,但对于查找失败的情况需要从头看到尾,因为无序排列,根据实际情况选择不同的方式,经常查找成功可以考虑上图方式。折半查找的查找效率,绿色节点为查找成功,紫色为查找失败,一共11个结点,每一层结点的数量*查到该层结点需要的步数的综合/11就是成功的ASL,失败同理。因为右子树的节点数一定比左子树多1个或等于左子树的结点,所以当两个数折半查找,画出查找判断树,2结点在右子树。所以要想算出他们的查找效率,我们需要画出来对应的查找判定树(根据折半查找的思想画图)
优先级队列-PriorityQueue
最新发布
qq_39203337的博客
11-14 328
无界队列，数据存储于内部数组中，数据采用堆(默认小顶锥)的组织形式。
LeetCode:215. 数组中的第K个最大元素
m0_75035023的博客
11-11 295
LeetCode:215. 数组中的第K个最大元素,数据结构与算法
数据结构-二叉树
wwwwwgery的博客
11-14 219
二叉树有左右儿子之分完美二叉树（满二叉树）除了最下面的没有儿子其他结点都有两个儿子，叶节点比较齐的，完全二叉树不是满二叉数允许缺失最后的结点满二叉树可以达到2^k-1边的总数=节点数-1。
C语言实现数据结构之堆
0xFFFFFFFF
11-08 1423
在这篇文章，我们使用C语言实现了一个物理存储结构为动态顺序表，逻辑结构为二叉树的堆，并实现了堆排序——一种比较快的排序
【数据结构】AVL树
2302_80026357的博客
11-11 388
本文主要介绍了数据结构中的AVL树
SystemVerilog学习笔记（三）：结构体与联合体
qq_38156104的博客
11-11 833
在 RTL 代码中，压缩结构体被视为单个向量，结构体中的每个数据类型都表示为位字段。不同的变量在结构内部保存不同的数据，称为结构成员。未压缩的结构比压缩的结构具有更多的内存占用。这里“int”是最大的数据类型，因此联合体中的所有其他成员共享 32 位。默认情况下，结构体最初是未压缩的形式，但可以使用“packed”关键字将其转换为压缩结构。“字节”占用 8 位，位[7:0] 为 8 位，逻辑[15:0] 为 16 位。结构与普通数组不同，因为数组仅使用相同类型和大小的元素，而结构体使用不同的数据类型。
atcoder beginner contest 265
12-17
atcoder beginner contest 265 是由日本 Atcoder 组织的一场面向初学者的比赛。这是一场在线编程竞赛，旨在为初学者提供机会锻炼和展示他们的编程技能。 这次比赛包括了多个题目，涉及到算法、数据结构、动态规划等各种编程知识。参赛者需要在规定的时间内完成题目，通过编写程序解决问题来积累得分。 atcoder beginner contest 265 的比赛时间通常在周末举行，为期约 2 到 2.5 个小时。比赛结束后，Atcoder 将公布排名和成绩，评选出优胜者。 这次比赛对于想要提升自己编程技能的初学者来说是一个很好的锻炼机会。通过这样的比赛，他们可以接触到不同类型的编程题目，提高解决问题的能力，增强对编程知识的理解。而且，比赛的排名和成绩也可以作为一种动力，激励他们持续学习和进步。 参与 atcoder beginner contest 265 的比赛，不仅可以锻炼编程技能，还可以结识来自世界各地的志同道合的朋友，一起学习、交流，共同进步。 总的来说，atcoder beginner contest 265 是一个很好的平台，提供了一个机会，让初学者们在编程领域不断学习、挑战自己，成长为更优秀的程序员。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值