AtCoder Beginner Contest 319(D-G)

最新推荐文章于 2024-11-14 19:11:37 发布
最新推荐文章于 2024-11-14 19:11:37 发布
阅读量373 收藏 1
点赞数
分类专栏： Atcoder 图论 动态规划 文章标签： c++ 数据结构 算法
kkk
本文链接：https://blog.csdn.net/scanner___yw/article/details/132812863
版权
Atcoder 同时被 3 个专栏收录
22 篇文章 1 订阅
订阅专栏
动态规划
21 篇文章 0 订阅
订阅专栏
图论
10 篇文章 0 订阅
订阅专栏
文章介绍了AtCoder编程比赛中的三个题目，涉及二维空间中单词排版的最小宽度计算，公交路线中到达时间的最短路径查询，以及在树上战斗中利用药剂和战斗力升级的问题。解题策略包括二分查找、状态转移和动态规划。
摘要由CSDN通过智能技术生成

D.Tasks - AtCoder Beginner Contest 319

        （1）题意

                给你一个M行得框框和N个单词，每个单词有一个宽度，每个单词之间应该用一个空格隔开，首位单词不需要，问至少需要多宽才能使得单词不会超过M行。

        （2）解题思路

                直接二分宽度，然后check即可。

        （3）代码实现

#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;
int L[N];
int n,m;
bool check(ll k)
{
    int cnt = 0;
    ll cur = 0;
    rep(i,1,n) {
        if(k < L[i]) {
            return false;
        }
    }
    rep(i,1,n) {
        if(cur - L[i] - 1 >= 0) {
            cur -= L[i] + 1;
        }
        else {
            cur = k - L[i];
            cnt ++;
        }
    }
    // cout << "???" << k << '\n';
    return cnt <= m;
}
void solve()
{
    cin >> n >> m;
    for(int i = 1;i <= n;i ++) {
        cin >> L[i];
    }
    ll l = 1,r = 1e18;
    while(l <= r) {
        ll mid = (l + r) >> 1;
        if(check(mid)) r = mid - 1;
        else l = mid + 1;
    }
    cout << l << endl;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    // cin >> T;
    while(T --) solve();
    return 0;
}

E - Bus Stops (atcoder.jp)

        （1）题意

                A要从自己家到B家，中间得路段构成是A先走一段路到达站点1，然后做公交到站点n，最后走一段路到B家，每一个站点得公交车会在P[i]倍数得时间发车，需要T[i]得时间才能到达下一个站，现在有q个询问，每个询问给定你起始时间，问最后达到B家得最小时间是多少。

        （2）解题思路

                考虑每一个P[i]得倍数都会有一些余数，不妨把他们得最小公倍数求出来，然后预处理出0-最小公倍数得起始时间需要花费多少时间到达B家。

        （3）代码实现

#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;
int p[N],t[N];
ll Ans[N];
int n,x,y;
ll calc(ll st)
{
    st += x;
    for(int i = 1;i < n;i ++) {
        int z = st % p[i];
        if(!z) z = p[i];
        st += p[i] - z;
        st += t[i];
    }
    return st + y;
}
void solve()
{
    cin >> n >> x >> y;
    set<int> pt;
    for(int i = 1;i < n;i ++) {
        cin >> p[i] >> t[i];
        pt.insert(p[i]);
    }
    int cur = 0;
    for(auto x : pt) {
        if(!cur) cur = x;
        else cur = cur * x / __gcd(cur,x);
    }
    for(int i = 0;i < cur;i ++) {
        Ans[i] = calc(i);
    }
    int q;
    cin >> q;
    for(int i = 1;i <= q;i ++) {
        ll v;
        cin >> v;
        int p = v % cur;
        cout << v - p + Ans[p] << '\n';
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    // cin >> T;
    while(T --) solve();
    return 0;
}

F - Fighter Takahashi (atcoder.jp)

        （1）题意

                你在一颗树上战斗，起初你的战斗力是1，树上每个点要么是药剂，要么是怪兽，如果是怪兽，你的战斗力大于等于他就可以击败他获取奖励战斗力，如果是药剂你可以使你得战斗力翻g[i]倍，现在问你是否可以从1号节点战败所有怪兽。

        （2）解题思路

                首先，若是你当前得实力够打怪兽，那么一定是先打得，如果不够了才考虑用药剂。那么一个很明显得思路是，确定一个吃药得顺序，然后bfs一遍看看能不能打完所有怪兽，那么时间复杂度显然是不太行得。所以我们考虑使用状压dp优化这个枚举吃药顺序得过程，状态dp[i]表示吃了i这些药最高能到得战斗力是多少，最后判一下是否大于等于最高战斗力得怪兽即可。

        （3）代码实现

#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 = 505;
int t[N],s[N],g[N],p[N];
vector<int> e[N];
ll dp[1<<(10)];
void solve()
{
    int n,tot = 0;
    cin >> n;
    vector<int> med,pos(n + 1,0);
    int master = 0;
    rep(i,2,n) {
        cin >> p[i] >> t[i] >> s[i] >> g[i];
        if(t[i] == 2) {
            med.pb(i);
            pos[i] = sz(med) - 1;
            tot ++;
        }
        master = max(master,s[i]);
        e[p[i]].pb(i);
    }
    memset(dp,-1,sizeof(dp));
    //dp[i]：表示吃了这些药能达到最大得能量值
    dp[0] = 1;
    rep(i,0,(1<<tot)-1) {
        if(dp[i] != -1) {
            priority_queue<pair<ll,int>,vector<pair<ll,int>>,greater<pair<ll,int>>> q;
            q.push({-1,1});
            vector<bool> used(sz(med),false);
            int cnt = 0;
            ll S = 0;
            while(!q.empty()) {
                auto [val,ver] = q.top();
                q.pop();
                if(val > dp[i]) break;
                cnt ++;
                if(t[ver] == 2 && !(i >> pos[ver] & 1)) {
                    used[pos[ver]] = true;
                    continue;
                }
                if(t[ver] == 1) {
                    dp[i] += g[ver];
                    S += g[ver];
                }
                for(auto v : e[ver]) {
                    if(t[v] == 2) q.push({-1,v});
                    else q.push({s[v],v}); 
                }
            }
            // cout << i << ' ' << dp[i] << '\n';
            if(dp[i] >= master || cnt == n) {
                cout << "Yes" << '\n';
                return;
            }
            rep(j,0,tot-1) {
                if(used[j]) {
                    dp[i | (1 << j)] = max(dp[i | (1 << j)],dp[i] * g[med[j]] - S);
                }
            }
        }
    }
    cout << "No" << '\n';
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    // cin >> T;
    while(T --) solve();
    return 0;
}

G - Counting Shortest Paths (atcoder.jp)

        （1）题意

                给你一个完全图，删除一些边后，问你是否能从1-N，如果能，请给出最短路径数量。

        （2）解题思路

               P1. 首先对于最短路径，我们考虑01bfs得特性，一旦有一个点进入了则不会再进入一次，因此我们可以用一个set维护一下未进入得点集，每次对于一个进入得点，扫描一下未进入得点集，若这个点和进入得点之间得边未删除，则可以把这个点加入队列，这样就可以很快得求得最短路径。

               P2.现在我们需要考虑路径数量得问题了，考虑将图分成如下形式。

                考虑dp[i]，表示i为最短路径上的点的方案数是多少。那么显然对于点集为2的点dp[i]等价于所有点集为1的点的方案和-i不能到达的点集为1的点的方案,依次类推求出dp[n]即可。

        （3）代码实现

#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;
set<int> e[N],g[N],pos;
int dis[N];
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();
    }
};
void solve()
{
    int n,m;
    cin >> n >> m;
    for(int i = 1;i <= m;i ++) {
        int u,v;
        cin >> u >> v;
        e[u].insert(v);
        e[v].insert(u);
    }
    for(int i = 2;i <= n;i ++) {
        pos.insert(i);
    }
    memset(dis,0x3f,sizeof(dis));
    dis[1] = 0;
    queue<int> q;
    q.push(1);
    while(!q.empty()) {
        int v = q.front();
        q.pop();
        auto nps = pos;
        for(auto x : nps) {
            if(!e[v].count(x) && pos.count(x)) {
                dis[x] = dis[v] + 1;
                pos.erase(x);
                q.push(x);
            }
        }
    }
    if(dis[n] >= n) {
        cout << -1 << '\n';
        return;
    }
    for(int i = 1;i <= n;i ++) {
        if(dis[i] <= n) g[dis[i]].insert(i);
    }
    vector<Mint> dp(n + 1,0),s(n + 1,0);
    dp[1] = 1;
    for(int i = 0;i < n;i ++) {
        if(i >= 1) {
            for(auto x : g[i]) {
                dp[x] += s[i];
            }
        }
        for(auto x : g[i]) {
            s[i + 1] += dp[x];
            for(auto y : e[x]) {
                if(dis[y] == dis[x] + 1) {
                    dp[y] -= dp[x];
                }
            }
        }
    }
    cout << dp[n];
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int T = 1;
    // cin >> T;
    while(T --) solve();
    return 0;
}

A real Warrior
关注
专栏目录
AtCoder Beginner Contest 263D - Left Right Operation
06-16
代码
AtCoder Beginner Contest 319 G - Counting Shortest Paths
weixin_60896526的博客
09-10 333
中维护集合表示未被遍历到的点，而一个节点在这个集合存在的次数不超过。后我们其实是在其补图上求最短路。
【OJ比赛日历】快周末了，不来一场比赛吗？ #09.09-09.15 #15场
CompHub的博客
09-07 431
实时聚合多平台的(Kaggle、天池…)和(Leetcode、牛客…）比赛。本账号会推送最新的比赛消息，欢迎关注！以下信息仅供参考，以比赛官网为准。
AtCoder题解集锦
热门推荐
天生我材必有用，千金散尽还复来。
04-15 1万+
AtCoder题解集锦 自己从全网整理的一些优质AtCoder题解，目前只有ABC（AtCoder Beginner Contest）的C~F。不定期更新。 如您有更多需求，欢迎私信我或在评论区留言！ 用法 表格查找 找到对应比赛的行 找到对应题目的列 该位置即为对应的题解 题号查找 在浏览器中按下搜索快捷键Ctrl+F，调出搜索窗口。 输入对应的题号，如244F 找到对应题解 标题查找 在浏览器中按下搜索快捷键Ctrl+F，调出搜索窗口。 输入题目标题，如Shortest Good
【atcoder】abc312~abc321题解
小学生蒟蒻
09-28 1769
把信息存进去然后找就行。
题解：AtCoder Beginner Contest 260 D-Changing Jewels
06-06
代码
题解：AtCoder Beginner Contest 261D - Flipping and Bonus
06-13
代码
题解：AtCoder Beginner Contest 262D - I Hate Non-integer Number
06-15
代码
题解：AtCoder Beginner Contest 262 C - Min Max Pair
06-14
代码，好简单。（请点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞点赞...
p4:cmu 15213/15513 csapp 深入理解计算机系统（寄存器、标志位/条件码、set指令、大端法小端法、逻辑左右移和算数左右移、字长概念）
shanshan的博客
11-11 498
可以简单记成，setg表示set greater，但是机器指令的参数顺序与我们习惯的顺序不同，机器指令是从右到左比较的。标志位都是一位，他们不是你直接设置的，而是计算机的算术指令自己设置的。在这里是零拓展的意思，将al的一字节的全0拓展为4字节，左边都补0。综上，机器指令的流程是，比较两个数，得到一字节的0或1，然后根据返回类型的字长要求，拓展为相应位数的0或1。这里setg指令根据sf条件码，假设为0，（说明y>x），那么最低位的单个字节也都设为0。将单个寄存器的单个字节根据条件码的值设为1或0。
C++——智能指针
Wangx_wang的博客
11-12 964
介绍了几种智能指针的不同和实现思路以及循环引用的问题
STL之vecor的使用(超详解)
2302_80220709的博客
11-11 780
如果发生的异地扩容，这时的迭代器就不在指向原来的空间，而就指向一块释放的内存，我们一旦继续访问就会报错，这种现象我们称为迭代器失效。指定位置插入，要注意的是这里不再像string一样，用的size_t 的pos，vector虽然也可以用下标访问，但是为了承接后面STL其他不支持下标访问的容器，所以这边的pos用的是迭代器类型。下面我们开始研究他的使用，为了能够更好的测试，我们先实现一个打印容器元素的函数，vector底层是数组，所以有三种访问方式：下标访问、迭代器访问、范围for（本质也是迭代器）
c++中，头文件包含iostream.h和`＜iostream＞`的差别
南东先生
11-11 414
`iostream.h` 和`` 包含的是同一个文件，二者在功能上没有差别,只是写法不同。使用``是C++标准推荐的方式。
TI毫米波雷达（五）—— chirp
最新发布
slyywd的博客
11-14 980
TI的毫米波雷达可以通过定义chirp配置文件来控制一帧中的chirp参数，而且可以在chirp RAM中修改这些配置文件。Chirp配置文件可以作为基础的chirp时序模板，用来生成参数各异的chirp。TI的毫米波雷达可以接收四个不同的chirp配置文件，但是chirp可配置RAM中可以预编程512个独特的chirp。每个chirp都可以引用四个配置文件之一，然后按需要进行细调。一个帧由chirp可配置RAM中起始索引到结束索引间的chirp序列组成，最大可循环255次。
C++ 内存分布及 new , delete 分配问题( ~~~ 面试重要 ~~~)
GAOSHOUCYUYAN的博客
11-10 842
本篇文章笔者将会对 C++ 中的内存问题简单的讲解 , 同时对 new , delete 的面试题进行重点讲解.以上就是本篇的内容 , 希望读者认真领会.
C++ 编程基础（5）类与对象 | 5.7、友元
个人技术博客
11-14 915
C++中的友元类与友元函数是一种强大的工具，它们允许程序员在保持类封装性的同时，实现对类内部数据的直接访问。然而，在使用时应谨慎考虑其对封装性、安全性和维护性的影响。只有在确实需要时才使用友元类和友元函数，以避免引入不必要的复杂性和潜在问题。
3195. 有趣的数-13年12月CCF计算机软件能力认证（组合数）
m0_73939047的博客
11-10 201
13年12月CCF计算机软件能力认证（组合数）
C++ 预处理器
wjs2024的博客
11-10 419
C++ 预处理器是 C++ 编译过程中的一个重要环节，它在真正的编译开始之前对源代码进行一系列的处理。预处理器的主要功能是处理源代码中的预处理指令，这些指令以号开头，它们指导预处理器执行特定的操作，如包含其他文件、宏定义、条件编译等。本文将详细介绍 C++ 预处理器的工作原理和常用指令。
2024年华为OD机试真题-光伏场地建设规划 -C++-OD统一考试（E卷）
面试高手的博客
11-11 199
第一行输入为调研的地区长，宽，以及准备建设的电站【长宽相等，为正方形】的边长，最低要求的发电量，之后每行为调研区域每平方公里的发电量。表示调研的区域大小为长2宽5的矩形，我们要建设的电站的边长为 2，建设电站最低发电量为 6。输入长为2，宽为5的场地，建设的场地为正方形场地，边长为1，要求场地的发电量大于等于6。输入长为2，宽为5的场地，建设的场地为正方形场地，边长为1，要求场地的发电量大于等于0。输入长为2，宽为5的场地，建设的场地为正方形场地边长为2，要求场地的发电量大于等于6。
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、付费专栏及课程。

余额充值