牛客小白月赛75

牛客小白月赛75

A–上班

题意****有两段路程，第一段固定时间，第二段选择不同的方式有两种时间，求总时间最短为？

题解：只要在后两个取min，再加上第一个就行

实现代码

#include <iostream>

using namespace std;

int main()
{
    int a , b , c;
    cin >> a >> b >> c;
    
    cout << a + min(b , c) << endl;
    
    return 0;
}

B— 崇拜

题意：有n个知识点，每个知识点为ai，如果讲一个知识点大于y的崇拜值+3，如果小于x的崇拜值-1，求讲解过程中崇拜值最大能为多少？

题解：很明显过程最大，那么就直接连续讲大于y的；

代码实现

#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
    int n , x , y;
    cin >> n >> x >> y;
    
    int ans = 0;
    for(int i = 0 ; i < n ; i ++ )
    {
        int a;
        cin >> a;
        
        if(a > y) ans += 3;
    }
    
    cout << ans << endl;
}

C–方豆子

我是菜狗，当时写不来就直接没写了

题意：求n级好豆子；

题解：该题能用循环或者递归去解决，这里用递归，由图可以发现每一级豆子都是由上一级组成，所以从递归到1，n级豆子就会有1 << n - 1 行个一级豆子组成，具体看代码实现

代码实现

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 1e6 + 10;

string a[10] = {"******","******","******","***...","***...","***..."};
string b[10] = {"......","......","......","...***","...***","...***"};
string ans[N];

void connect1(int x)
{
    for(int i = 0 ; i < 6 ; i ++ )
        ans[x + i] += a[i];
}

void connect2(int x)
{
    for(int i = 0 ; i < 6 ; i ++ )
        ans[x + i] += b[i];
}

void dfs(int u , int x , int y) // u表示递归到第几级，x表示1为一级好逗子，0为一级坏豆子，y表示该该豆子需要放置的横坐标
{
    if(u == 1)//如果到第一级则在ans字符串后连接一级豆子
    {
        if(x == 1) connect1(y);
        else connect2(y);
        return ;
    }
    
    //每一级豆子分为四块
    //下部分的豆子，上部分有着1 << u - 2 个一级豆子
    //所以下半部分的坐标加上 (1 << u - 2) * 6;
    dfs(u - 1 , !x , y);
    dfs(u - 1 , !x , y);
    dfs(u - 1 , !x , y + (1 << u - 2) * 6);
    dfs(u - 1 , x , y + (1 << u - 2) * 6);
}
    
int main()
{
    int n;
    cin >> n;
    
    dfs(n , 1 , 0);
    
    for(int i = 0 ; i < 1 << n - 1 ; i ++ )
        for(int j = 0 ; j < 6 ; j ++ )
            cout << ans[i * 6 + j] << endl;
    
    return 0;
}

D–矩阵

题意：

题解：采用BFS求解此题，首先该题与spfa算法相似，每个点能够选择上下左右四个方向，每个方向又有两种情况，如果相邻不相同则代价+1 ，相同则+2，
如果原来的总代价大于此次可以更新的总代价，那么就更新该点的最小总代价，同时判断该点是否在队列里，若不在则插入，因为到最后可能是1也可能是0，所以答案为min(d[n][m][0] , d[n][m][1]);

代码实现

#include <bits/stdc++.h>

using namespace std;

const int N = 1010;

int n, m;
int d[N][N][2];
bool st[N][N][2];
char g[N][N];

int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};

void bfs()
{
    memset(d, 0x3f, sizeof d);
    d[0][0][g[0][0] - '0'] = 0;

    queue<array<int, 3>> q;
    q.push({0, 0, g[0][0] - '0'});

    while (q.size())
    {
        auto [x, y, z] = q.front();
        q.pop();
        st[x][y][z] = false;

        for (int i = 0; i < 4; i ++ )
        {
            int a = x + dx[i], b = y + dy[i];
            if (a < 0 || a >= n || b < 0 || b >= m) continue;
            int now = g[a][b] - '0';
            if (now != z)
            {
                if (d[a][b][now] > d[x][y][z] + 1)
                {
                    d[a][b][now] = d[x][y][z] + 1;
                    if (!st[a][b][now])
                    {
                        q.push({a, b, now});
                        st[a][b][now] = true;
                    }
                }
            }
            else
            {
                if (d[a][b][z ^ 1] > d[x][y][z] + 2)
                {
                    d[a][b][z ^ 1] = d[x][y][z] + 2;
                    if (!st[a][b][z ^ 1])
                    {
                        q.push({a, b, z ^ 1});
                        st[a][b][z ^ 1] = true;
                    }
                }
            }
        }
    }
}

int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i ++ ) cin >> g[i];

    bfs();

    cout << min(d[n - 1][m - 1][0], d[n - 1][m - 1][1]) << "\n";

    return 0;
}