牛客周赛Round 51补题记录

B：小红的三倍数

        知道下面的这个结论甚至都不需要模拟这个的拼接过程，（就算真拼接也会暴int）

证明：一个数的各位数之和能被3整除，则该数能被3整除

#include<iostream>
using namespace std;
int n;
string t;
int sum;
int main(){
    cin >> n;
    while(n --){
        cin >> t;
        for(int i = 0; i < t.length(); i ++){
            sum += t[i] - '0';
        }
    }
    if(sum % 3 == 0)    cout << "YES";
    else                cout << "NO";
    return 0;
}

C：小红充电

本题核心在于分类讨论：（1）一开始就在超级充电的mode下，那就直接超级充满电（2）若在超级充电的阈值之上，则需要进一步讨论（2.1）可以直接正常不玩手机充完电（2.2）也可以为了触发超级充电，先不充电玩手机到阈值t，然后触发超级充电。

未AC的原因（过了90%）：精度问题

        

要使得误差小于1e-6，就至少要保留6位小数

#include<iostream>
#include<iomanip>
using namespace std;

long double x, y, t, a, b, c;
int main(){
    cin >> x >> y >> t >> a >> b >> c;
    if(x <= t){    // 触发超级充电
        long double m = (100 - x) / c;
        cout << fixed << setprecision(9) << m;
    }else{//    不触发超级充电
        long double m = (100 - x) / b;    // 充电但是不玩手机(非超级充电模式)
        // cout << m << endl;
        // 先不充电玩到超级充电mode
        long double r = (x - t) / y;
        r += (100 - t) / c;
        // cout << r << endl;
        m = min(m, r);
        cout << fixed << setprecision(9) << m;
    } 
    return 0;
}

补充一下：补充前导零的方式

cout << setw(5) << setfill('0') << 123;

D：小红的gcd

本题的a是一个大整数，超出了long long，应该利用gcd的性质如下：

        gcd(a, b) = gcd(a - b, b) = gcd(a - 2b, b) =......= gcd(a % b, b)

#include<iostream>
#include<string>
#define int long long
using namespace std;
string a;
int b;

int gcd(int a, int b){
    return b ? gcd(b, a % b): a;
}

signed main(){
    cin >> a >> b;
    int ra = 0;
    for(int i = 0; i < a.length(); i ++){
        ra *= 10;
        ra += a[i] - '0';
        ra = ra % b;
    }
    cout << gcd(ra, b);
    return 0;
}

讲解E题前，看一道leetcode题 1631.最小体力消耗路径

解法一：二分+DFS/BFS(这里的dfs/bfs只是为了测试连通性)

枚举所需的体力值是具有二段性的，所以可以二分答案。

二分+DFS写法

①leetcode中如何使用全局变量？函数内就不要再重复int声明了（会局部屏蔽）

②用到下一个点的坐标时，一定再此前先检测一下坐标的合法性。heights[nex][ney]

③是否需要回溯的问题：

class Solution {
public:
    int n, m;
    int dx[5] = {1, 0, -1, 0}, dy[5] = {0, 1, 0, -1};
    bool st[110][110] = {0};
    bool dfs(vector<vector<int>>& heights, int mid, int x, int y){  // 对于体力mid能否找到一条出去的路径
        //cout << "n = " << n << " m = " << m << endl;
        if(x == n - 1 && y == m - 1)    return true;    // 说明能够走到这边
        for(int i = 0; i < 4; i ++){
            int nex = x + dx[i], ney = y + dy[i];
            if(nex < n && nex >= 0 && ney >= 0 && ney < m && !st[nex][ney]){ //①下一个坐标符合要求后才能求cost!!!②要没走过才能够走
                int cost = abs(heights[x][y] - heights[nex][ney]);
                if(cost <= mid){                // 消耗体力值不超过mid才能够走
                    st[nex][ney] = true;
                    if(dfs(heights, mid, nex, ney))  return true;
                    //st[nex][ney] = false;       // 恢复现场no!->从这个点走不通，那么打了false后面还会重复走这个点
                }
            }
        }
        return false;
    }
    int minimumEffortPath(vector<vector<int>>& heights) {
        ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);
        n = heights.size(),m = heights[0].size();   // 千万不能用int,否则变成了局部变量
        int l = 0, r = 1e6;
        while(l < r){
            int mid = (l + r) >> 1;
            memset(st, 0, sizeof(st));
            st[0][0] = true;
            if(dfs(heights, mid, 0, 0))     r = mid;
            else                            l = mid + 1;   
        }
        return l;
    }
};

二分+BFS写法

class Solution {
public:
    typedef pair<int, int> PII;
    int n, m;
    int dx[5] = {1, 0, -1, 0}, dy[5] = {0, 1, 0, -1};
    bool st[110][110] = {0};
    bool bfs(int mid, vector<vector<int>>& heights){
        queue<PII> q;
        q.push({0, 0});
        st[0][0] = true;
        while(!q.empty()){
            PII t = q.front(); q.pop();
            int x = t.first, y = t.second; 
            for(int i = 0; i < 4; i ++){
                int nex = x + dx[i], ney = y + dy[i];
                if(nex >= 0 && nex < n && ney >= 0 && ney < m && !st[nex][ney]){
                    int cost = abs(heights[x][y] - heights[nex][ney]);
                    if(cost <= mid){
                        st[nex][ney] = true;
                        q.push({nex, ney});
                    }
                }
            }
        }
        return st[n - 1][m - 1];
    }
    int minimumEffortPath(vector<vector<int>>& heights) {
        ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);
        n = heights.size(),m = heights[0].size();   // 千万不能用int,否则变成了局部变量
        int l = 0, r = 1e6;
        while(l < r){
            int mid = (l + r) >> 1;
            memset(st, 0, sizeof(st));
            if(bfs(mid, heights))           r = mid;
            else                            l = mid + 1;   
        }
        return l;
    }
};

解法二：并查集

核心思路：实际上就是通过并查集来实时监测起点到终点的连通性。最终的体力值一定是边权值，所以，我们首先将所有的边信息存储起来，从小到大排序。然后依次从小到大加入边，并实时检查连通性，若因为为边x的加入导致起点和终点的连通，那么边x的权值w就是最终问题的答案，即最小的cost。

实现细节注意：如何将网格图进行建边。

class Solution {
public:
    static const int N = 1e4 + 10;
    // 并查集
    int p[N];
    int find(int x){
        if(p[x] != x)   p[x] = find(p[x]);
        return p[x];
    }
    // 边类型定义
    struct edge{
        int a, b, w;
        bool operator<(const struct edge& x)const {
            return w < x.w;
        }
    };

    int minimumEffortPath(vector<vector<int>>& heights) {
        int n = heights.size(), m = heights[0].size();
        int totalnum = n * m;
        for(int i = 1; i <= totalnum; i ++)
            p[i] = i;   // 并查集初始化

        vector<struct edge> v;
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < m; j ++){
                // 与右侧结点构成的边
                if(j + 1 < m){
                    v.push_back({m * i + j + 1, m * i + j + 2, abs(heights[i][j] - heights[i][j + 1])});
                }
                // 与下侧结点构成的边
                if(i + 1 < n)
                    v.push_back({m * i + j + 1, m * (i + 1) + j + 1, abs(heights[i][j] - heights[i + 1][j])});
            }
        }
        sort(v.begin(), v.end());   // 按照边的权值从小到大排序一下
        for(auto val: v){           // 每次添加val这条边
            int a = val.a, b = val.b, w = val.w;
            p[find(a)] = find(b);
            if(find(p[1]) == find(p[totalnum])) //因为添加这条边而连通了,这个边权值就是答案
                return w;
        }
        return 0;
    }
};

解法三：Dijkstra

        关于为什么可以用迪杰斯特拉算法求解改问题的最短路，需要对A*算法和迪杰斯特拉算法有一定了解，等补充完相关知识后再详细研究下证明：

class Solution {
public:
    typedef pair<int, int> PII;
    bool st[10010];
    int dist[10010];
    int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
    int INF = 0x3f3f3f3f;
    /*int getm(int a, int b){
        if(a == INF)    return b;
        return max(a, b);
    }*/
    int minimumEffortPath(vector<vector<int>>& heights) {
        int n = heights.size(), m = heights[0].size();
        priority_queue<PII, vector<PII>, greater<PII>> q;   // 小根堆
        q.push({0, 0});                     // first是距离起点的距离,second是结点编号
        memset(dist, 0x3f, sizeof dist);
        dist[0] = 0; // st[0] = true;
        while(q.size()){
            PII t = q.top(); q.pop();
            if(st[t.second])   // 访问过了,去除冗余
                continue;    
            st[t.second] = true;
            int x = t.second / m, y = t.second % m;   // 当前位置的数组下标
            for(int i = 0; i < 4; i ++){
                int nx = x + dx[i], ny = y + dy[i];
                if(nx>=0&&nx<n&&ny>=0&&ny<m){
                    int tp = nx * m + ny;
                    if(dist[tp] > max(t.first, abs(heights[x][y] - heights[nx][ny]))){
                        dist[tp] = max(t.first, abs(heights[x][y] - heights[nx][ny]));
                        q.push({dist[tp], tp});
                    }
                }
            }
        }
        return dist[n * m - 1];
    }
};

E：小红走矩阵

为什么不能用dp:

        dp要求有向无环图， 无后效性。本题不能满足（环形、绕原路等，，，）

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int N = 510;
// 二分 + DFS
int n;
int g[N][N];
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
bool st[N][N];

bool dfs(int x, int y, int curpath_cost, int mid){
    if(x == n - 1 && y == n - 1)    return true;    // 是连通的
    
    for(int i = 0; i < 4; i ++){
        int nex = x + dx[i], ney = y + dy[i];
        if(nex >= 0 && nex < n && ney >= 0 && ney < n && !st[nex][ney]){// 要访问没访问过的！
            if(max(curpath_cost, g[nex][ney]) <= mid){
                curpath_cost = max(curpath_cost, g[nex][ney]);
                st[nex][ney] = true;
                if(dfs(nex, ney, curpath_cost, mid))    return true;
                // 这边不需要恢复现场（只是检测连通性）
            }
        }
    }   
    return false;
}

int main(){
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    cin >> n;
    for(int i = 0; i < n; i ++)
        for(int j = 0; j < n; j ++)
            cin >> g[i][j];
    int l = 1, r = 1e9;    
    while(l < r){
        int mid = (l + r) >> 1;
        memset(st, 0, sizeof st), st[0][0] = 1;
        if(dfs(0, 0, g[0][0], mid))    r = mid;
        else         l = mid + 1;
    }
    cout << r;
    return 0;
}

F：小红的数组（线段树板子,见相关专题）