AtCoder Beginner Contest 340（A-G）

最新推荐文章于 2024-07-17 12:13:29 发布
最新推荐文章于 2024-07-17 12:13:29 发布
阅读量339 收藏 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
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AtCoder Beginner Contest 224题解 A-G
10-24 3993
AtCoder Beginner Contest 224 签到题、简单题 A - Tires 判断一个字符串是不是以er或ist结尾。 直接做即可 #include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; int n = s.size(); if (n >= 2 && s[n-1]=='r' && s[n-2]=
AtCoder Beginner Contest 263D - Left Right Operation
06-16
代码
AtCoder Beginner Contest 356 A-E
2301_80210089的博客
06-01 817
分析：我们可以考虑先将M拆分成二进制， 那么二进制位置上为1的才是有效的， 然后枚举这些位置, 判断0-N上有多少数在这些位置上为1，然后全部加起来。题目大意：给出一个长度为n的数组，求所有的二元组{i， j}满足i<j，的max(a[i], a[j]) / min(a[i], a[j])向下取整的和。赛时cwa了两发， 错在数组开小了，没注意M是偏大的，改了一次后没注意还要一个跟M相关，有点粗心了，f和g还有半小时，有思路但不多，这场感觉还行。时间复杂度：O(2^n * m * c)分析：直接模拟即可。
AtCoder Beginner Contest 258 A-G
qq_56195933的博客
07-04 481
本场感觉EF挺有意思。 B - Number Box C - Rotation 题意： 给定一个字符串S，给定Q个查询。 1 x:把最后x个字符移到S前面。 2 x:输出此时第x个字符。 2
AtCoder Beginner Contest 361（A-G）
qq_67224001的博客
07-08 753
题目给定一颗无根树，先考虑固定一个根起点的情况，由于要走完所有的点，所以如果不在我们的最后一条路径上的话，其余每条路径都要经过两遍，由此对于当前情况的最好结果是 ： 路径和 * 2 - 最长子路径。可以先考虑一维，比如先考虑 z 轴是否相交，如果两个长方体的 z 轴不相交，那么不可能会有交的体积。按照题解的写法，将空白格子划分为 1 * n 的矩形，然后将包含（-1，-1）的矩形放入进行bfs即可。换根时，考虑是子树的两条路径，还是子树一条路径与父节点的路径和哪个最大就可。代码实现有点烂，最好看看别人的。
ATCoder Beginner Contest 340 A~G
Code_Shark的博客
02-15 816
输出首项为a，末项为b，公差为d的等差数列。
Atcoder Beginner Contest 335 （A - F 题）
Edward Shi的博客
01-07 1210
Atcoder Beginner Contest 335 的A到F题讲解
AtCoder Beginner Contest 268G - Random Student ID
qq_53282173的博客
09-13 212
AtCoder Beginner Contest 268 G - Random Student ID 字典树 思维 概率期望
AtCoder Beginner Contest 276 G - Count Sequences 差分
qq_45377553的博客
11-06 586
好难阿，组合数学
AtCoder Beginner Contest 222 E - Red and Blue Tree（dfs dp）
我们都有光明的未来
10-10 289
linkkkkk 题意： 给出nnn个点的树和长度为mmm的序列aaa。现需要给每条边染成red/bluered/bluered/blue色，要求按照aaa走的路径，经过的边数r−b=kr-b=kr−b=k，问方案数。 思路： 首先可以通过dfsdfsdfs将序列aaa的路径经过每条边的次数cic_ici​统计出来。这样问题就变成了从c1,c2,……cn−1c_1,c_2,……c_{n-1}c1​,c2​,……cn−1​中选择一些数和为rrr，剩余的数和为bbb，满足r−b=kr-b=kr−b=k 假设s
AtCoder Beginner Contest 334 A~F
Code_Shark的博客
12-26 634
给出球拍和手套的价格，哪个贵买哪个，要求输出购买的物品。
题解：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
代码
数据结构第32节 无锁编程
最新发布
hummhumm的专栏
07-17 832
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
常见排序算法总结
mydaily_的博客
07-16 784
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1880
栈超超超详解
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 230
1%29%5D。
atcoder beginner contest 265
12-17
atcoder beginner contest 265 是由日本 Atcoder 组织的一场面向初学者的比赛。这是一场在线编程竞赛，旨在为初学者提供机会锻炼和展示他们的编程技能。 这次比赛包括了多个题目，涉及到算法、数据结构、动态规划等...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值