AtCoder Beginner Contest 190 A -F题解

Polyness

于 2021-02-02 00:43:10 发布

阅读量300

点赞数 1

分类专栏： CF 文章标签：算法动态规划

本文链接：https://blog.csdn.net/Einsteinme/article/details/113532517

版权

CF 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

前两天做了一下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。我们也可以对所有可能的放置状态进行状态压缩，节省代码量，提高代码可读性。简言之，我们可以把选择情况压缩成一个二进制数，如果第 $i$ 个人放在 $C_i$ 里，二进制数该位为0；如果放在 $D_i$ 里，二进制数该位为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的级数的数目。
$\sum_i^ja = (a_i+a_j)*(a_j-a_i+1)/2$
我们先只考虑正级数。
我们只要找到：
$(i + j) * (j - i + 1) = 2 * N$
的所有情况。
我们对 $2 * 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;
}

Polyness

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
AtCoder Beginner Contest 190 A -F题解

前两天做了一下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)#prag
复制链接

扫一扫