AtCoder Beginner Contest 211 A~E题解

A - Blood Pressure

• 题意
  计算$\frac{A-B}{3}+B$

• 解题思路
  注意$\frac{A-B}{3}$得到的结果是不是整数，即判断能否整除$3$.

• AC代码

/**
  *@filename:A
  *@author: pursuit
  *@csdn:unique_pursuit
  *@email: 2825841950@qq.com
  *@created: 2021-07-24 19:59
**/
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const int N = 100000 + 5;
const int P = 1e9+7;

int a,b;
void solve(){
}
int main(){
    cin >> a >> b;
    if((a - b) % 3){
        printf("%.7lf\n",(a - b) * 1.0 / 3 + b);
    }
    else{
        cout << (a - b) / 3 + b << endl;
    }
    solve();
    return 0;
}

B - Cycle Hit

• 题意
  给出一系列字符串，判断要求的字符串是否在里面。

• 解题思路
  利用$map$或者其他容器纪录出现的字符串，最后判断要求的字符串是否在里面即可。

• AC代码

/**
  *@filename:B
  *@author: pursuit
  *@csdn:unique_pursuit
  *@email: 2825841950@qq.com
  *@created: 2021-07-24 20:03
**/
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const int N = 100000 + 5;
const int P = 1e9+7;

string s;
map<string,int> p;
void solve(){
}
int main(){
    for(int i = 0; i < 4; ++ i){
        cin >> s;
        p[s] ++;
    }
    if(p["H"] && p["2B"] && p["3B"] && p["HR"]){
        cout << "Yes" << endl;
    }
    else{
        cout << "No" << endl;
    }
    solve();
    return 0;
}

C - chokudai

• 题意
  给你一个字符串，计算出该字符串中有多少个字串为chokudai。

• 解题思路
  对于这种问题，和最长公共子序列是一个类型的，只不过这里是统计方案数。我们先定义好状态：$dp[i][j]$表示前$i$个字符，已经匹配到了chokudai中的第$j$个字符的方案数。先来分析初始状态。对于$j=0$，我们知道，由于不需要匹配，所以方案数自然为$1$。对于$i=0,j>0$，由于没有字符可供匹配，所以方案数为$0$。那么至此，我们来分析状态转移，即当前第$i$个字符是不是和第$j$个字符相等：如果$s1[i]=s2[j]$，说明我们这个时候的$dp[i-1][j-1]$和$dp[i-1][j]$状态都可以转移到$dp[i][j]$，即$dp[i][j]=dp[i-1][j-1]+dp[i-1][j]$；若不相等，则$dp[i-1][j-1]$无法转移，故为$dp[i][j]=dp[i-1][j$。故此题得解。

• AC代码

/**
  *@filename:C
  *@author: pursuit
  *@csdn:unique_pursuit
  *@email: 2825841950@qq.com
  *@created: 2021-07-24 20:06
**/
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const int N = 100000 + 5;
const int P = 1e9+7;

int dp[N][10];//dp[i][j]表示前i个已经配对到匹配字符串中的第j个字符的组合数。
char s[N];
void solve(){
    char temp[10] = " chokudai";
    int len1 = strlen(s + 1),len2 = strlen(temp + 1);
    for(int j = 1; j <= len2; ++ j){
        dp[0][j] = 0;
    }
    for(int i = 0; i <= len1; ++ i){
        dp[i][0] = 1;
    }
    for(int i = 1; i <= len1; ++ i){
        for(int j = 1; j <= len2; ++ j){
            if(s[i] == temp[j]){
                dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % P;
            }
            else{
                dp[i][j] = dp[i - 1][j];
            }
        }
    }
    cout << dp[len1][len2] << endl;
}
int main(){
    cin >> s + 1;
    solve();
    return 0;
}

D - Number of Shortest paths

• 题意
  给你一个$n$个顶点$m$条边的无向图，现在需要你计算出从$1$到$n$的最短路径有多少条。

• 解题思路
  自然是利用$bfs$来解决，但这里我们需要注意的一点就是要考虑我们扩散的点是不是已经遇到了被初始化成最短路，如果是，且从当前点到该点和最短路径是一样的，那么说明我们有两种途径可以到达，这这两种途径的方案数进行相加即可。

• AC代码

/**
  *@filename:D
  *@author: pursuit
  *@csdn:unique_pursuit
  *@email: 2825841950@qq.com
  *@created: 2021-07-24 20:14
**/
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const int N = 200000 + 5;
const int INF = 0x3f3f3f3f;
const int P = 1e9+7;

struct node{
    int to,next;
}edges[N << 1];
int head[N],tot;
int n,m,u,v;
int cnt[N],dist[N];//dist为最短路径数组。dist[i]表示1到i的最短路径。
void add(int u,int v){
    edges[++ tot].to = v;
    edges[tot].next = head[u];
    head[u] = tot;
}
void bfs(){
    queue<int> q;
    q.push(1);
    while(!q.empty()){
        int u = q.front();
        q.pop();
        for(int i = head[u]; i; i = edges[i].next){
            int v = edges[i].to;
            if(dist[v] == INF){
                //说明没有初始化。
                dist[v] = dist[u] + 1;
                cnt[v] = cnt[u];
                q.push(v);
            }
            else if(dist[v] == dist[u] + 1){
                //说明已经被初始化过了。且最短路径是由此过来的。
                cnt[v] += cnt[u];
                cnt[v] %= P;
            }
        }
    }
}
void solve(){
    fill(dist,dist + N,INF);
    dist[1] = 0;
    cnt[1] = 1;
    bfs();
    cout << cnt[n] << endl;
}
int main(){
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m; ++ i){
        scanf("%d%d", &u, &v);
        add(u,v),add(v,u);
    }
    solve();
    return 0;
}

E - Red Polyomino

• 题意
  给你$n\times n$的单元矩阵，其中各单元属性要么是白要么是黑，现在需要你计算出有多少种方案可以将白块绘制成红块，使得这个区域连通且大小为$k$。

• 解题思路
  很容易想到$dfs$，但我们需要进行大量的剪枝操作，即当我们处理过的地图存储起来即可。注意从每个白块出发一次。在$dfs$的过程中回溯一定要回归原来的状态。

• AC代码

/**
  *@filename:E
  *@author: pursuit
  *@csdn:unique_pursuit
  *@email: 2825841950@qq.com
  *@created: 2021-07-25 11:17
**/
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const int N = 100000 + 5;
const int P = 1e9+7;

int n,k,ans;
vector<string> s;
int go[4][2] = {0,1,0,-1,1,0,-1,0};
map<vector<string>,int> p;//去重。
bool flag;
void dfs(int num){
    //从(x,y)出现，还剩k个需要染色。
    if(p[s]){
        return;
    }
    p[s]++;
    if(num == 0){
        /* for(int i = 0; i < s.size(); ++ i){
            cout << s[i] << endl;
        }
        cout << endl; */
        ans ++;
        return;
    }
    for(int i = 0; i < n; ++ i){
        for(int j = 0; j < n; ++ j){
            if(s[i][j] == '.'){
                for(int c = 0; c < 4; ++ c){
                    int dx = i + go[c][0],dy = j + go[c][1];
                    if(dx >= 0 && dx < n && dy >= 0 && dy < n && s[dx][dy] == 'r'){
                        s[i][j] = 'r';
                        dfs(num - 1);
                        s[i][j] = '.';
                    }
                }
            }
        }
    }
}
void solve(){
    for(int i = 0; i < n; ++ i){
        for(int j = 0; j < n; ++ j){
            if(s[i][j] == '.'){
                s[i][j] = 'r';
                dfs(k - 1);
                s[i][j] = '.';
            }
        }
    }
    cout << ans << endl;
}
int main(){
    cin >> n >> k;
    s.resize(n);
    for(int i = 0; i < n; ++ i){
        cin >> s[i];
    }
    solve();
    return 0;
}