AtCoder Beginner Contest 190 A -F题解

最新推荐文章于 2025-01-11 15:01:35 发布
原创 最新推荐文章于 2025-01-11 15:01:35 发布 · 416 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #动态规划

本文解析AtCoder初赛190各题，包括简单条件判断、数组枚举、状态压缩DFS等算法，并给出C++实现代码。

前两天做了一下AtCoder Beginner Contest 190的比赛，场内做出了(A, B, C, D, F)5题，E题只剩不到20分钟了，场内有思路，没时间写了，赛后补了一下。
我就简单讲解一下所有题目的思路。

A - Very Very Primitive Game

思路：本题是一个if判断，比较大小，分情况讨论的题目，直接模拟即可。

#pragma GCC optimize("-Ofast","-funroll-all-loops")
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include <bits/stdc++.h>
using namespace std;
//#define int long long
//#define ULL unsigned long long
#define fi first
#define se second
#define ls 2 * rt
#define rs 2 * rt + 1
#define PII pair<int,int>
#define PDD pair<double, double>
#define gcd(a,b) __gcd(a,b)
#define lowbit(x) (x & (-x))
typedef long long ll;
const int N = 1e5 + 5;
const int M = 2e5 + 5;



void solve(){
    int a, b, c;
    cin >> a >> b >> c;
    if(!c){
        if(a > b){
            cout << "Takahashi" << "\n";
        }
        else{
            cout << "Aoki" << "\n";
        }
    }
    else{
        if(b > a){
            cout << "Aoki" << "\n";
        }
        else{
            cout << "Takahashi" << "\n";
        }
    }
}

int main(){
    solve();

#ifndef ONLINE_JUDGE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    
    return 0;
}

B - Magic 3

思路：本题在数组中找是否有一个合法答案，直接从前往后枚举即可，注意审好题，看清( > , >=, <, <=)的关系。

#pragma GCC optimize("-Ofast","-funroll-all-loops")
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include <bits/stdc++.h>
using namespace std;
//#define int long long
//#define ULL unsigned long long
#define fi first
#define se second
#define ls 2 * rt
#define rs 2 * rt + 1
#define PII pair<int,int>
#define PDD pair<double, double>
#define gcd(a,b) __gcd(a,b)
#define lowbit(x) (x & (-x))
typedef long long ll;
const int N = 1e5 + 5;
const int M = 2e5 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;

int n, s, d;
int x[N];
int y[N];
int ok[N];
void solve(){
    cin >> n >> s >> d;
    for(int i = 1; i <= n; i++){
        cin >> x[i] >> y[i];
    }
    for(int i = 1; i <= n; i++){
        ok[i] = 0;
    }
    for(int i = 1; i <= n; i++){
        if(x[i] >= s || y[i] <= d){
            ok[i] = 1;
        }
    }
    int fi = 0;
    for(int i = 1; i <= n; i++){
        if(ok[i] == 0){
            fi = 1;
            break;
        }
    }
    if(fi){
        cout << "Yes" << "\n";
    }
    else{
        cout << "No" << "\n";
    }
}

int main(){
    solve();

#ifndef ONLINE_JUDGE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    
    return 0;
}

C - Bowls and Dishes

思路：K比较小，显示可以直接暴力dfs。我们也可以对所有可能的放置状态进行状态压缩，节省代码量，提高代码可读性。简言之，我们可以把选择情况压缩成一个二进制数，如果第iii个人放在CiC_iCi​里，二进制数该位为0；如果放在DiD_iDi​里，二进制数该位为1。我们可以把dfs变成对二进制数的枚举。

#pragma GCC optimize("-Ofast","-funroll-all-loops")
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include <bits/stdc++.h>
using namespace std;
//#define int long long
//#define ULL unsigned long long
#define fi first
#define se second
#define ls 2 * rt
#define rs 2 * rt + 1
#define PII pair<int,int>
#define PDD pair<double, double>
#define gcd(a,b) __gcd(a,b)
#define lowbit(x) (x & (-x))
typedef long long ll;
const int N = 1e5 + 5;
const int M = 2e5 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;

int n, m;
int a[110], b[110];
int k;
int c[110], d[110];
int vis[110];
void solve(){
    cin >> n >> m;
    for(int i = 1; i <= m; i++){
        cin >> a[i] >> b[i];
    }
    cin >> k;
    for(int i = 1; i <= k; i++){
        cin >> c[i] >> d[i];
    }
    int nn = (1 << k) - 1;
    int ans = 0;
    for(int t = 0; t <= nn; t++){
        memset(vis, 0, sizeof vis);
        for(int i = 1; i <= k; i++){
            int bi = (( t >> (i-1) ) & 1);
            if(bi == 0){
                vis[c[i]] = 1;
            }
            else{
                vis[d[i]] = 1;
            }
        }
        int res = 0;
        for(int i = 1; i <= m; i++){
            if(vis[a[i]] && vis[b[i]]){
                res++;
            }
        }
        ans = max(ans, res);
    }
    cout << ans << "\n";
}

int main(){
    solve();

#ifndef ONLINE_JUDGE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    
    return 0;
}

D - Staircase Sequences

思路：找公差为1和等于N的级数的数目。
∑ija=(ai+aj)∗(aj−ai+1)/2\sum_i^ja = (a_i+a_j)*(a_j-a_i+1)/2∑ij​a=(ai​+aj​)∗(aj​−ai​+1)/2
我们先只考虑正级数。
我们只要找到：
(i+j)∗(j−i+1)=2∗N(i + j)*(j - i + 1) = 2*N(i+j)∗(j−i+1)=2∗N
的所有情况。
我们对2∗N2*N2∗N因数分解即可，看有多少组正级数满足条件。
因为一个正级数可以通过左侧填0，负数构造一个级数，我们把答案乘2就好了。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

ll n;
ll sum[1000010];

void solve(){
    cin >> n;
    ll t = 2*n;
    ll ans = 1ll;
    //cout << t << "\n";
    for(ll i = 1; i * i <= t; i++){
        if(t % i == 0){
            //cout << i << "\n";
            ll g2 = i, g1 = t/i;
            //cout << x << " " << y << "\n";
            if((g1 - g2 + 1)%(2ll)==0 && (g1+g2-1)%(2ll)==0){
                //cout << "ok" << "\n";
                ans = ans*(1ll*2);
                //cout << ans << "\n";
            }
        }
    }
    cout << ans << "\n";
}

int main(){
    solve();
    return 0;
}

E - Magical Ornament

本题K比较小，我们考虑状态压缩。我们要先预处理K个点到其它所有点的最短距离，用bfs就能得到最优解。然后要枚举终点，和此时的状态压缩的覆盖情况，覆盖为(1 << k ) - 1，才有可能得出最优解。因为有安排顺序的问题，要dfs加记忆化搜索，即可得出答案。

#pragma GCC optimize("-Ofast","-funroll-all-loops")
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include <bits/stdc++.h>
using namespace std;
//#define int long long
//#define ULL unsigned long long
#define fi first
#define se second
#define ls 2 * rt
#define rs 2 * rt + 1
#define PII pair<int,int>
#define PDD pair<double, double>
#define gcd(a,b) __gcd(a,b)
#define lowbit(x) (x & (-x))
typedef long long ll;
const int N = 1e5 + 5;
const int M = 2e5 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
// const ll mod = 1e9 + 7;
// const ll inf = 0x3f3f3f3f3f3f3f3f;

int n, m;
int k;
int dist[20][100010];
int c[20];
int dp[18][1 << 18];
int vis[100010];
vector<int> path[100010];

void bfs(int u){
    for(int i = 1; i <= n; i++){
        dist[u][i] = inf;
    }
    memset(vis, 0, sizeof vis);
    dist[u][c[u]] = 0;
    queue<int> q;
    q.push(c[u]);
    vis[c[u]] = 1;
    while(!q.empty()){
        int f = q.front();
        q.pop();
        for(auto v : path[f]){
            if(!vis[v]){
                vis[v] = 1;
                dist[u][v] = dist[u][f] + 1;
                q.push(v);
            }
        }
    }

}

int solve(int i, int zt){
    if(zt == (1 << k) - 1){
        return 0;
    }
    if(dp[i][zt] != -1){
        return dp[i][zt];
    }
    int res = inf;
    for(int j = 0; j < k; j++){
        if(((1 << j)&zt)){
            continue;
        }
        res = min(res, solve(j, zt | (1 << j)) + dist[j][c[i]] );
    }
    return dp[i][zt] = res;
}


void solve(){
    cin >> n >> m;
    for(int i = 1; i <= m; i++){
        int a, b;
        cin >> a >> b;
        path[a].push_back(b);
        path[b].push_back(a);
    }
    cin >> k;
    for(int i = 0; i < k; i++){
        cin >> c[i];
        bfs(i);
    }
    int ok = 1;
    for(int i = 0; i < k; i++){
        if(dist[i][c[0]] >= inf){
            ok = 0;
            break;
        }
    }
    if(!ok){
        cout << "-1" << "\n";
        return ;
    }
    memset(dp, -1, sizeof dp);
    int ans = inf;
    for(int i = 0; i < k; i++){
        ans = min(ans, 1 + solve(i, 1 << i));
    }
    cout << ans << "\n";
    return ;
}

int main(){
    solve();

#ifndef ONLINE_JUDGE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
    
    return 0;
}

F - Shift and Inversions

思路：我们可以先通过归并排序求出原序列的逆序对。然后每一次把序列的第一个数轮换到序列末尾，看逆序对数是多少。每一次只需要找到序列第一个数在全排列中的位置，进行相应的更新即可，我使用了二分查找。

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
int _;
int n;
int a[300010];
int b[300010];
int c[300010];
int d[300010];
ll cnt;

void merge_sort(int l, int r){
    if(l + 1 >= r)//涓€涓厓绱犱笉鐢ㄦ帓搴?
        return ;
    int mid = (l+r)/2;
    merge_sort(l, mid), merge_sort(mid, r);
    int l1 = l, r1= mid;
    int l2 = mid, r2 = r;
    int tot = l;
    while(l1 < r1 || l2 < r2){
        if((l1 < r1 && a[l1] <= a[l2]) || l2 >= r2){
            b[tot++] = a[l1++];
        }
        else{
            b[tot++] = a[l2++];
            cnt += 1ll*(r1 - l1);
        }
    }

    for(int i = l; i < r; i++)
        a[i] = b[i];    
}

int main(){
    cin >> n;
    for(int i = 0; i < n; i++){
        cin >> a[i];
        c[i] = a[i];
        d[i] = i;
    }
    cnt = 0;
    merge_sort(0, n);
    cout << cnt << "\n";
    for(int k = 0; k < n-1; k++){
        int t = lower_bound(d, d+n, c[k]) - d;
        cnt -= 1ll*t;
        cnt += 1ll*(n - 1 - t);
        cout << cnt << "\n";
	}
    return 0;
}
AtCoder Beginner Contest 190解题报告
weixin_43911947的博客
01-31 628
题目链接：abc190 A - Very Very Primitive Game 题目大意 Takahashi 和 Aoki吃糖果，轮流吃糖果，如果轮到的人没糖果了那么就输。 a是T拥有的糖果数，b是A拥有的糖果数，c=0说明T先吃，c=1说明A先吃。 输出赢家 0≤A,B≤100 思路 A先吃说明T已经吃完一颗了，所以可以让a+c，那么就统一T先吃糖果了 如果a>b则T赢，否则A赢 ac代码 #include<bits/stdc++.h> using namespa.
AtCoder Beginner Contest 420 A至G 题解
最新发布
cwplh的博客
08-25 1283
本文摘要： 该文章记录了5道编程题的解题思路和代码实现。A题通过取模运算确定月份；B题模拟投票过程计算得分；C题通过预处理优化查询操作；D题使用BFS解决迷宫问题，考虑状态转换；E题利用并查集高效处理连通性查询。每道题都给出了清晰的解题方法和完整的代码实现，涵盖了模拟、预处理、广度优先搜索和并查集等算法思想。
AtCoder Beginner Contest 190 C Bowls and Dishes（暴搜）
qq_45377553的博客
01-30 1329
Bowls and Dishes 题意： 给你n个dish。有m个条件。 一个条件要成立，那么它要两个给定的dish中有球。 现在又k个人。每个人可以选择一个dish然后放球，且每个人有两个选择。 问：怎样可以使得 m个条件尽量成立。 思路： 数据小，可以考虑直接暴搜。 AC #include <iostream> #include <bits/stdc++.h> #define For(i,x,y) for(int i=(x); i<=(y); i++) #define
AtCoder Beginner Contest 190
青少年趣味编程
01-11 885
AtCoder Beginner Contest 190
题解：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 190 简易题解报告和 AC 代码（缺 D、E、F 题）
努力中的老周的专栏
01-31 461
A - Very Very Primitive Game 题目链接 https://atcoder.jp/contests/abc190/tasks/abc190_a。 简易题解 还是一个签到题。 我们根据输入 c 进行判断。如果 c==0，表示 Takahashi 先开始，那么Takahashi 必须必 Aoki 有跟多的糖果才能赢，即 a>b。同理，如果 c==1，表示 Aoki 先开始，那么Aoki 必须必 Takahashi 有跟多的糖果才能赢，即 b>a。 AC 代码 ..
AtCoder Beginner Contest 190 D - Staircase Sequences唯一分解定理
狙击美佐的博客
01-30 2495
AtCoder Beginner Contest 190 D - Staircase Sequences唯一分解定理题意思路 传送门：https://atcoder.jp/contests/abc190/tasks/abc190_d 题意 给一个N，问有多少种等差数列（公差为1）的和等于N，输出个数。给一个N，问有多少种等差数列（公差为1）的和等于N，输出个数。给一个N，问有多少种等差数列（公差为1）的和等于N，输出个数。 思路 假设我们选择的等差数列为[a,b]，则根据题意可以得到假设我们选择的等差数列为
AtCoder Beginner Contest 190 题解（A-D）
BNDSllx的博客
01-30 683
AtCoder Beginner Contest 190 题目A - Very Very Primitive Game 思路：模拟 代码： #include <bits/stdc++.h> using namespace std; int main() { int a, b, c; cin >> a >> b >> c; if(c == 0) { if(a > b) { cout << "Takahashi"; } els
AtCoder Beginner Contest 190 A~D 题解
天生我材必有用，千金散尽还复来。
02-01 8765
ABC190 A~D 题解 A - Very Very Primitive Game B - Magic 3 C - Bowls and Dishes D - Staircase Sequences
AtCoder Beginner Contest 190 | 全题解
一只酷酷光儿的博客
01-30 1463
鸽了建模队友的一晚，悄悄地写个atcoderatcoderatcoder没人发现吧？ 悄悄地akakak，不让他们发现 AtCoder Beginner Contest 190A.Very Very Primitive Game题目大意：题目思路：Code:B.Magic 3题目大意：题目思路：Code:C.Bowls and Dishes题目大意：题目思路：Code:D.Staircase Sequences题目大意：题目思路：Code：E.Magical Ornament题目大意：题目思路：Code:F
AtCoder Beginner Contest 180
一个小菜鸡的博客
07-16 363
A. // #pragma GCC optimize(2) #include <algorithm> #include <iostream> #include <sstream> #include <cstring> #include <cstdio> #include <random> #include <cctype> #include <bitset> #include <string> #
AtCoder Beginner Contest 408 题解
06-02
<think>好的，用户现在想找AtCoderBeginner Contest408的题解或解题思路。我需要先确认这个比赛是否已经结束，以及是否有公开的题解资源。由于AtCoder通常会在比赛后一段时间内发布官方题解，但有时候社区成员或博客作者也会分享他们的解题方法。首先，我应该检查用户提供的引用内容，但看起来用户之前的引用是关于其他比赛的，比如ABC093和ABC405，可能与当前问题无关。不过，用户可能需要类似的解题思路结构，比如分题讲解、代码示例等。接下来，我需要考虑用户可能的真实需求。他们可能参加了比赛但遇到困难，或者想通过题解来学习算法和编程技巧。因此，回答需要结构清晰，分题目讲解思路，并给出关键点的解决方法，可能的话提供代码示例。 由于我无法直接访问外部网站，无法提供最新的ABC408的具体题解，但可以给出一般性的解题步骤和常见问题的解决方法。例如，对于ABC的题目，通常前几题涉及基础算法、模拟、数学问题等，后面题目可能涉及动态规划、图论等更复杂的算法。需要注意的是，用户可能希望得到具体的解题思路，比如每道题的关键点、算法选择以及代码实现。因此，我应该分题目进行说明，可能按照A到F题的顺序，逐一简要讲解。另外，用户可能需要参考之前的类似题解的格式，比如分题说明、代码示例等。同时，根据用户之前的引用中提到的代码结构，可能需要使用Python或C++等语言的代码示例。最后，生成的相关问题应该围绕如何准备AtCoder比赛、常见题型解析、算法学习资源等，帮助用户进一步深入学习。</think>### AtCoder Beginner Contest 408 题解思路概述 根据AtCoder比赛惯例，ABC 408包含6道题目（A-F），难度递增。以下为通用解题框架： #### A题（基础语法题） 通常考察输入输出和简单计算。例如： ```python a, b = map(int, input().split()) print(a + b % 24) ``` **关键点**：注意时间循环处理[^1] #### B题（条件判断） 可能涉及字符串处理或坐标判断。例如检测网格中的特定模式： ```python grid = [input() for _ in range(9)] count = 0 for i in range(9): for j in range(9): if grid[i][j] == '#' and check_pattern(i,j): count +=1 print(count) ``` #### C题（贪心/数学） 常需数学建模，如求最大最小值的排列组合： $$ \max\left(\sum_{i=1}^n a_i \cdot b_{\sigma(i)}\right) $$ 可通过排序后对应相乘解决[^2] #### D题（图论/动态规划） 典型解法示例： ```python from collections import deque def bfs(start): q = deque([start]) dist = [-1]*(n+1) dist[start] = 0 while q: u = q.popleft() for v in graph[u]: if dist[v] == -1: dist[v] = dist[u]+1 q.append(v) return max(dist) ``` #### E-F题（高级算法） 可能涉及： 1. 线段树区间查询 2. 网络流建模 3. 组合数学优化
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值