Atcoder Beginner Contest 317

最新推荐文章于 2024-11-12 12:29:51 发布
最新推荐文章于 2024-11-12 12:29:51 发布
阅读量100 收藏
点赞数
分类专栏： Atcoder Beginner Contest 文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74087709/article/details/132550369
版权

 A - Potions (atcoder.jp)

AC代码:

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#define endl '\n'
//#define int long long
using namespace std;
typedef long long ll;
const int N=110;
int a[N];
int n,h,x;
void solve() {
    cin>>n>>h>>x;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=1;i<=n;i++){
        if(h+a[i]>=x){
            cout<<i<<endl;
            return;
        }
    }
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t=1;
//    cin>>t;
    while(t--) {
        solve();
    }
    return 0;
}

B - MissingNo. (atcoder.jp)

AC代码:

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<set>
#define endl '\n'
//#define int long long
using namespace std;
typedef long long ll;
int n;
void solve() {
    cin>>n;
    set<int>s;
    int maxn=0;
    for(int i=1;i<=n;i++){
        int x;
        cin>>x;
        maxn=max(maxn,x);
        s.insert(x);
    }
    int y=*s.begin();
    for(int i=y;i<=maxn;i++){
        if(!s.count(i)){
            cout<<i<<endl;
            return;
        }
    }
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t=1;
//    cin>>t;
    while(t--) {
        solve();
    }
    return 0;
}

C - Remembering the Days (atcoder.jp)

一开始想的是最大生成树,但是了第三个样例后,知道这是不行的,因为不能有重复路径,树是可以走重复路径的

然后想到用dfs,对于每一个点进行dfs,然后对于找到的单向路径长度之和取max

错误代码:

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<vector>
#define endl '\n'
//#define int long long
using namespace std;
typedef long long ll;
typedef pair<int,int>PII;
const int N=15;
int vis[N];
vector<PII>e[N];
int n,m;
int ans;
void dfs(int x,int d) {
    vis[x]=1;
    if(!e[x].size()) {
        ans = max(ans, d);
        return;
    } else {
        for(auto v:e[x]) {
            int ver=v.first,dist=v.second;
            if(!vis[ver]) {
                dfs(ver,d+dist);
            }
        }
    }
}
void solve() {
    cin>>n>>m;
    for(int i=1; i<=m; i++) {
        int a,b,c;
        cin>>a>>b>>c;
        e[a].push_back({b,c});
        e[b].push_back({a,c});
    }
    ans=0;
    for(int i=1; i<=n; i++) {
        for(int j=1; j<=n; j++) vis[j]=0;
        dfs(i,0);
    }
    cout<<ans<<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[x],size()不可能等于0

其实完全可以一直赋值的,因为是取max,一直赋值的话是完全没有问题的

或者在遍历子节点时看有没有标记过的节点

第二个错误在于dfs没有恢复现场,当对图进行dfs时,一定要恢复现场

对图进行dfs的板子是固定的,如下:

void dfs(int x){
    vis[x]=1;
    for(auto v:e[x]){
        if(!vis[v]) dfs(v);
    }
    vis[x]=0;
}

AC代码: 

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<vector>
#define endl '\n'
//#define int long long
using namespace std;
typedef long long ll;
typedef pair<int,int>PII;
const int N=15;
int vis[N];
vector<PII>e[N];
int n,m;
int ans;
void dfs(int x,int d) {
    vis[x]=1;
        ans=max(ans,d);
        for(auto v:e[x]) {
            int ver=v.first,dist=v.second;
            if(!vis[ver]) {
                dfs(ver,d+dist);
            }
        }
    vis[x]=0;
}
void solve() {
    cin>>n>>m;
    for(int i=1; i<=m; i++) {
        int a,b,c;
        cin>>a>>b>>c;
        e[a].push_back({b,c});
        e[b].push_back({a,c});
    }
    ans=0;
    for(int i=1; i<=n; i++) {
        for(int j=1;j<=n;j++) vis[j]=0;
        dfs(i,0);
    }
    cout<<ans<<endl;
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t=1;
//    cin>>t;
    while(t--) {
        solve();
    }
    return 0;
}

D - President (atcoder.jp)

一开始想贪心,每次贪席位最多的,但是后面想了想是不可能的,因为可能席位最多的那个,需要转移很多很多很多很多的票

如果一开始有贪心的思路,那么先不要急着写代码,先思考该贪心思路是否真的可行

错误代码:

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<stack>
#define endl '\n'
#define int long long
using namespace std;
typedef long long ll;
const int N=110;
int n;
struct node{
    int x,y,z;
    int diff;
    bool operator<(const node &W)const{
        if(z==W.z) return diff<W.diff;
        return z>W.z;
    }
}q[N];
void solve() {
    cin>>n;
    int sum=0;
    for(int i=1;i<=n;i++) {
        cin>>q[i].x>>q[i].y>>q[i].z;
        if(q[i].y>q[i].x) q[i].diff=q[i].y-q[i].x;
        else q[i].diff=0;
        sum+=q[i].z;
    }
    sort(q+1,q+1+n);
    int res=0;
    int ans=0;
//    for(int i=1;i<=n;i++){
//        cout<<q[i].x<<' '<<q[i].y<<' '<<q[i].z<<endl;
//    }
    for(int i=1;i<=n;i++){
        res+=q[i].z;
        if(q[i].diff) ans+=q[i].diff/2+1;
        if(sum-res<res) break;
    }
    cout<<ans<<endl;
}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t=1;
//    cin>>t;
    while(t--) {
        solve();
    }
    return 0;
}

 

这题其实是01背包的变式,与经典的01背包问题不同,f[i][j]表示在前i个物品里选,价值为j所需要的物品最小重量

该题f[i][j]表示在前i场投票中选择若干场投票进行票数转移,赢得j个席位所需要转移的最少票数

枚举席位数,从0到sum

for(int i=1;i<=n;i++){
    for(int j=0;j<=sum;j++){
        //不获得第i场的席位
        f[i][j]=f[i-1][j];
        //获得第i场的席位
        if(a[i]>b[i]&&j-c[i]>=0) f[i][j]=min(f[i][j],f[i-1][j-c[i]]+0);//如果a[i]本来就大于b[i],那么不需要转移票数,直接获得席位,从j-c[i]转移到j,加0表示不需要转移票
        else if(a[i]<=b[i]&&j-c[i]>=0) f[i][j]=min(f[i][j],f[i-1][j-c[i]]+(b[i]-a[i])/2+1);//由于该场获得了c[i],所以从j-c[i]转移到j,最少需要转移的票数为(b[i]-a[i])/2+1
    }
}

这样的话,需要f[100][1e7],这样就爆空间了,所以优化为一维 

for(int i=1;i<=n;i++){
    for(int j=sum;j>=c[i];j--){
        if(a[i]>b[i]) f[j]=min(f[j],f[j-c[i]]+0);//如果a[i]本来就大于b[i],那么不需要转移票数,直接获得席位,从j-c[i]转移到j,加0表示不需要转移票
        else if(a[i]<=b[i]) f[j]=min(f[j],f[j-c[i]]+(b[i]-a[i])/2+1);//由于该场获得了c[i],所以从j-c[i]转移到j,最少需要转移的票数为(b[i]-a[i])/2+1
    }
}

AC代码: 

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#define endl '\n'
#define int long long
using namespace std;
typedef long long ll;
const int N=110,M=1e7+10;
int a[N],b[N],c[N];
int f[M];
int n;
void solve() {
    cin>>n;
    int sum=0;
    for(int i=1; i<=n; i++) {
        cin>>a[i]>>b[i]>>c[i];
        sum+=c[i];
    }
    memset(f,0x3f,sizeof f);
    f[0]=0;
    for(int i=1; i<=n; i++) {
        for(int j=sum; j>=c[i]; j--) {
            if(a[i]>b[i]) f[j]=min(f[j],f[j-c[i]]+0);//如果a[i]本来就大于b[i],那么不需要转移票数,直接获得席位,从j-c[i]转移到j,加0表示不需要转移票
            else if(a[i]<=b[i]) f[j]=min(f[j],f[j-c[i]]+(b[i]-a[i])/2+1);//由于该场获得了c[i],所以从j-c[i]转移到j,最少需要转移的票数为(b[i]-a[i])/2+1
        }
    }
    int ans=1e18;
    //枚举席位数大于半数时最少需要转移的票数
    for(int i=(sum+1)/2;i<=sum;i++){
        ans=min(ans,f[i]);//一直取min就行了,某些席位i可能组成不了(因为席位都是一个个离散的数,不是连续的),则f[i]为无穷大
    }
    cout<<ans<<endl;
}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t=1;
//    cin>>t;
    while(t--) {
        solve();
    }
    return 0;
}

E - Avoid Eye Contact (atcoder.jp)

最短路,用bfs

AC代码:

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#define endl '\n'
//#define int long long
using namespace std;
typedef long long ll;
const int N=2010;
char s[N][N];
int vis[N][N];//标记是否可走以及是否走过
int h,w;
int x,y;
int dx[4]= {-1,1,0,0},dy[4]= {0,0,-1,1};
struct node {
    int x,y;
    int d;
};
queue<node>q;
int bfs() {
    q.push({x,y,0});
    s[x][y]='#';
    while(q.size()) {
        auto t=q.front();
        q.pop();
        int x=t.x,y=t.y,d=t.d;
        for(int i=0; i<4; i++) {
            int tx=x+dx[i],ty=y+dy[i];
            if(tx<1||tx>h||ty<1||ty>w) continue;
            if(vis[tx][ty]==1||s[tx][ty]=='#') continue;
            if(s[tx][ty]=='G') return d+1;
            if(s[tx][ty]='.') {
                q.push({tx,ty,d+1});
                s[tx][ty]='#';
            }
        }
    }
    return -1;
}
void solve() {
    cin>>h>>w;
    for(int i=1; i<=h; i++) {
        for(int j=1; j<=w; j++) {
            cin>>s[i][j];
            if(s[i][j]=='S') {
                x=i;
                y=j;
            }
        }
    }
    //预处理障碍
    for(int i=1; i<=h; i++) {
        for(int j=1; j<=w; j++) {
            if(s[i][j]=='^') {
                vis[i][j]=1;
                int k=i-1;
                while(k>=1&&(s[k][j]=='.'||s[k][j]=='S'||s[k][j]=='G')) {
                    vis[k][j]=1;
                    k--;
                }
            } else if(s[i][j]=='v') {
                vis[i][j]=1;
                int k=i+1;
                while(k<=h&&(s[k][j]=='.'||s[k][j]=='S'||s[k][j]=='G')) {
                    vis[k][j]=1;
                    k++;
                }
            } else if(s[i][j]=='<') {
                vis[i][j]=1;
                int k=j-1;
                while(k>=1&&(s[i][k]=='.'||s[i][k]=='S'||s[i][k]=='G')) {
                    vis[i][k]=1;
                    k--;
                }
            } else if(s[i][j]=='>') {
                vis[i][j]=1;
                int k=j+1;
                while(k<=w&&(s[i][k]=='.'||s[i][k]=='S'||s[i][k]=='G')) {
                    vis[i][k]=1;
                    k++;
                }
            }
        }
    }
//    cout<<endl;
//    for(int i=1;i<=h;i++){
//        for(int j=1;j<=w;j++){
//            cout<<vis[i][j];
//        }
//        cout<<endl;
//    }
    cout<<bfs()<<endl;
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t=1;
//    cin>>t;
    while(t--) {
        solve();
    }
    return 0;
}
沫刃起
关注
专栏目录
AtCoder Beginner Contest 317 题解 A-E
xiaoqian7758258的博客
08-27 446
AtCoder Beginner Contest 317 题解 A-E，二分，排序，dfs，dp，01背包，bfs
AtCoder Beginner Contest 317（A~E题）讲解
Edward Shi的博客
08-26 1036
Atcoder ABC 317：A~E题讲解
AtCoder Beginner Contest 359
qq_58297895的博客
06-23 1553
这场我赛时打的非常不好，只做出了2题。
Atcoder Beginner Contest 350
djhws144的博客
04-25 1983
ABC350
AtCoder Beginner Contest 368
2301_78527293的博客
08-27 907
A - G
AtCoder Beginner Contest 365
congyuyoudao的博客
08-04 1039
对于B的顺序,我们无法直接通过贪心来得到我们需要的答案,因为我们可以可以通过故意平手来达到控制我们出手顺序的结果.对于这个题目,我们可以发现无后效性,对于当前出什么,只受到前面一个出手的影响.对于补贴可以无限大的情况,当且只有数组的总和小于等于M才行。对于这一次出什么,我们把两种情况(平手或者胜利)都考虑了.因为我们需要找到x的最大值,直接通过二分查找X即可.直接用sort排序以后输出第二大的数的下标即可。给你一个年份,判断当前年份有多少天。A与B进行猜拳,已知A的出手顺序.给你一个数组,找到第二大的数。
AtCoder Beginner Contest 360
2302_79454804的博客
07-01 420
找出在时间（T+0.1）之前，蚂蚁i和j（1≤i
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 858
AtCoder Beginner Contest 363 ABCDE
AtCoder Beginner Contest 369 题解
nike0good |Oier&ACMer | 熟能生巧
09-01 1176
A - 369 #include<bits/stdc++.h> using namespace std; #define For(i,n) for(int i=1;i<=n;i++) #define Fork(i,k,n) for(int i=k;i<=n;i++) #define ForkD(i,k,n) for(int i=n;i>=k;i--) #define Rep(i,n) for(int i=0;i<n;i++) #define ForD(i,n) for(
AtCoder Beginner Contest 239
Z_Y_S_的博客
02-20 758
G 就是个最小割板子，但是打比赛时一直以为求最小割方案就是把流满的边当作割边，机房里几个人还同时犯了这个错误，错误的点的数量一样，当时一致认为数据有问题，事实上需要从源点开始跑广搜，找出源点不经过流量为000的边所能到达的所有的点记为SSS集，其余点记为TTT集，如果有一条边上的两个点所在集合不一样，那这条边就是割边 F 关键是怎么设状态，一开始设f(x)f(x)f(x)表示当前数为xxx，期望经过几次操作大于mmm，怎么推都只能推出一个暴力dpdpdp，事实上如果把状态设为f(x)f(x)f(x)表示从1
AtCoder Beginner Contest 229
Code_Shark的博客
12-06 388
AtCoder Beginner Contest 229 A. On and Off 题目描述 ​ 给你一个2×22\times 22×2的矩阵，由字符 ... ，#组成 问你能否从任意一个#不经过 ... 走到任意一个# 分析 ​ 也就是让我们判断是否联通 我们可以记录下来每个#的位置，然后如果连通，那么对于每个#必然有一个其他的#与他相邻 代码 #include<bits/stdc++.h> using namespace std; int main() { ios::sync
AtCoder Beginner Contest 285解题报告
m0_73935863的博客
01-16 813
AtCoder Beginner Contest 285解题报告
AtCoder Beginner Contest 206
m0_49959202的博客
06-30 380
文章目录AtCoder Beginner Contest 206A - Maxi-BuyingB - SavingsC - SwappableD - KAIBUNsyoE - Divide BothF - Interval Game 2 AtCoder Beginner Contest 206 A - Maxi-Buying 题意： 题解： 代码： #include <bits/stdc++.h> #define int long long #define debug(x) cout <
AtCoder Beginner Contest 223
Code_Shark的博客
10-18 257
A. 简单判断 一张纸币的面值为 100100100，至少 111 张，给定钱数 XXX，判断是否可能是钱包里的钱 判断是否是 100100100 的倍数 判断 XXX 是否为 000 #include<bits/stdc++.h> using namespace std; int x; int main(void) { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> x; if (x % 10
STL set
hls0611的博客
11-09 250
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
PCA（主成分分析）算法的应用场景
huanfeng_AI的博客
11-09 535
需要注意的是，PCA并不适用于所有场景。例如，当数据之间存在非线性关系时，PCA可能无法完全揭示数据的内在结构。此外，PCA对初始变量的顺序和标签敏感，不同的变量顺序可能导致不同的主成分结果。因此，在选择数据分析方法时，需要根据具体的数据和任务需求来决定是否使用PCA。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1461
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
0-Equity-Transformer：求解NP-Hard Min-Max路由问题的顺序生成算法（AAAI-24)(完)（code）
最新发布
太极生两鱼
11-12 81
最小最大路由问题旨在通过智能体合作完成任务来最小化多个智能体中最长行程的长度。这些问题包括对现实世界有重大影响的应用场景，但已知属于NP-hard问题。现有方法在大规模问题上面临挑战，尤其是在需要协调大量智能体以覆盖数千个城市的情况下。本文提出了Equity-Transformer来解决大规模最小最大路由问题。首先，我们采用顺序规划方法来处理最小最大路由问题，使我们能够利用强大的序列生成器（例如，Transformer）。其次，我们提出了关键的归纳偏差，以确保智能体之间的公平工作量分配。
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、付费专栏及课程。

余额充值