AtCoder Beginner Contest 212 题解（A-E）

AtCoder Beginner Contest 212 题解（A-E）

A. Alloy

题目大意：

根据输入的两个整数$a$和$b$，分情况输出答案。

解题思路：

签到题。

代码：

#include<bits/stdc++.h>
using namespace std;
int a,b;
int main()
{
    cin>>a>>b;
    if(a>0&&b>0) puts("Alloy");
    else if(a>0) puts("Gold");
    else puts("Silver");
    return 0;
}

B. Weak Password

题目大意：

给出一个长度为$4$的字符串，判断是否满足题目的条件，分情况输出答案。

解题思路：

签到题

代码：

#include<bits/stdc++.h>
using namespace std;
char a[4];
int main()
{
    cin>>a;
    if(a[0]==a[1]&&a[1]==a[2]&&a[2]==a[3]) puts("Weak");
    else{
        bool flag=true;
        for(int i=0;i<3;i++){
            int x=a[i]-'0';
            if(a[i+1]-'0'!=(x+1)%10){
                flag=false;
                break;
            }
        }
        puts(flag?"Weak":"Strong");
    }
    return 0;
}

C. Min Difference

题目大意：

给出长度为$N$的整数序列$A$和长度为$M$的整数序列$B$，求$\min |A_i-B_j|$，其中$1\le i\le N,1\le j\le M$。

解题思路：

暴力做法的时间复杂度是$O(N\times M)$，肯定是行不通的。

我们知道，对于每个数而言，其实只用计算比自己大和自己小的离自己最近的两个数即可。

• 如果$A_i>B_j$，相较于增加$A_i$，还是增加$B_j$更有意义。

所以我们考虑将两个序列按升序排序之后，再通过双指针算法来控制$A_i$和$B_j$尽可能接近。

时间复杂度$O(N+M)$

代码：

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+10;
int a[N],b[N];
int n,m;
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    for(int i=1;i<=m;i++) scanf("%d",&b[i]);
    sort(a+1,a+1+n);
    sort(b+1,b+1+m);
    int res=1e9;
    for(int i=1,j=1;i<=n&&j<=m;){
        res=min(res,abs(a[i]-b[j]));
        if(a[i]>b[j]) j++;
        else i++;
    }
    printf("%d\n",res);
    return 0;
}

D. Querying Multiset

题目大意：

一共会进行$Q$次操作，每次操作有三种类型：

1. 在一个空球上面写一个整数$X$,并把这个球放入包内。
2. 对于包内的所有球，将每个球上面的整数加上$X$。
3. 输出包中所有球上的最小的数字，并把这个球扔掉。

解题思路：

维护一个累加值和一个小根堆。

因为每个数字入堆的先后顺序不一样，为了维护堆中数字的相对关系，在每个数字加入到堆中之前，先减去累加值，取出的时候再加上新的累加值，两个累加值的差值即是取出的数字在堆中的时候需要加上的。

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int n;
priority_queue<LL,vector<LL>,greater<LL> > heap;
LL sum;
int main()
{
    scanf("%d",&n);
    while(n--){
        int op,x;
        scanf("%d",&op);
        if(op==1){
            scanf("%d",&x);
            heap.push(x-sum);
        }
        else if(op==2){
            scanf("%d",&x);
            sum+=x;
        }
        else{
            printf("%lld\n",heap.top()+sum);
            heap.pop();
        }
    }
    return 0;
}

E. Safety Journey

题目大意：

有$N$座城市，每对城市之间都有一条双向通行的道路，因为某些原因，现在有$M$条道路无法使用。

现在从城市$1$出发旅行$K$天，最后一天回到城市$1$。旅游的城市序列如$A_0,A_1,...,A_k$，其中$A_0=A_k=1$。

问一共有多少种不同的旅行方案。

• $2\le N\le 5000$
• $0\le M\le \min (\frac{N\times (N-1)}{2},5000)$
• $2\le K\le 5000$

解题思路：

如果一共有$m$条可以通行的道路，很容易想到时间复杂度为$O((N+m)\times K)$的dp做法。

因为可通行的道路最大是$\frac{N\times (N-1)}{2}$，所以这种做法是会超时的。

所以我们可以转换一下思路，将原本的dp在进行状态转移的时候进行一点的优化。

定义状态$f[i][j]$为从起点走$i$步到城市$j$的方案数，原先$f[i][j]$是由所有的$f[i-1][j^{\prime }]$转移过来的，其中$j^{\prime }$是跟$j$之间道路联通的城市。

现在可以选择曲线救国，每次先将上一步的所有方案数求和，即$\sum _{k=1}^{N}f[i-1][k]$。然后再减去无法到达$j$的那些城市的方案数，就能得到$f[i][j]$。注意图中是不存在自环的，所以每次要减去$f[i-1][j]$。时间复杂度$O((N+M)\times K)$。

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=5010,mod=998244353;
int h[N],e[N*2],ne[N*2],idx;
int n,m,k;
LL f[N][N];
void add(int a,int b){
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
int main()
{
    scanf("%d%d%d",&n,&m,&k);
    memset(h,-1,sizeof h );
    while(m--){
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b);
        add(b,a);
    }
    f[0][1]=1;
    for(int i=1;i<=k;i++){
        LL sum=0;
        for(int j=1;j<=n;j++) sum+=f[i-1][j];
        for(int j=1;j<=n;j++){
            f[i][j]=sum-f[i-1][j];
            for(int x=h[j];~x;x=ne[x]){
                int u=e[x];
                f[i][j]-=f[i-1][u];
            }
            f[i][j]%=mod;
        }
    }
    printf("%lld\n",f[k][1]);
    return 0;
}