【2022/04/30-第77场双周赛】复盘

加入了残酷刷题群，所以之后都用全球排名衡量。

Q1.统计是给定字符串前缀的字符串数目

给定一个主串和一个字符串数组，求出字符串数组元素中是主串前缀数组的个数。

class Solution {
public:
    int countPrefixes(vector<string>& words, string s) {
        unordered_set<string> st;
        for(int i = 1; i <= s.size(); ++i) st.insert(s.substr(0, i));
        int ret = 0;
        for(auto i : words) if(st.find(i) != st.end()) ++ret;
        return ret;
    }
};

Q2.最小平均差

前缀和，但是因为accumulate函数的返回值是等于容器内元素类型，所以之前算rsum时溢出了，WA了两发。

class Solution {
public:
    int minimumAverageDifference(vector<int>& nums) {
        int n = nums.size(), mind = INT_MAX, ret = 0;
        long long rsum = 0, lsum = 0;
        for(auto i : nums) rsum += i;
        for(int i = 0; i < n; ++i){
            lsum += nums[i];
            rsum -= nums[i];
            long long lavg = lsum / (i + 1);
            long long ravg = (i == n - 1 ? 0 : rsum / (n - 1 - i)); 
            // cout << lavg << ' ' << ravg << endl;
            if(mind > abs(lavg - ravg)){
                mind = abs(lavg - ravg);
                ret = i;
            }
        }
        return ret;
    }
};

Q3.统计网格图中没有被保卫的格子数

从四个方向分别记录保安可以保卫的格子。

class Solution {
public:
    int countUnguarded(int m, int n, vector<vector<int>>& g, vector<vector<int>>& w) {
        vector<vector<int>> h(m, vector<int>(n, 0));
        for(auto i : g) h[i[0]][i[1]] = 2;
        for(auto i : w) h[i[0]][i[1]] = -1;
        for(int i = 0; i < m; ++i){ // 从左到右和从右到左
            int flag = 0;
            for(int j = 0; j < n; ++j){
                if(flag && h[i][j] == 0) h[i][j] = 1;
                if(h[i][j] == 2) flag = 1;
                if(h[i][j] == -1) flag = 0;
            }
            flag = 0;
            for(int j = n - 1; j >= 0; --j){
                if(flag && h[i][j] == 0) h[i][j] = 1;
                if(h[i][j] == 2) flag = 1;
                if(h[i][j] == -1) flag = 0;
            }
        }

        for(int j = 0; j < n; ++j){ // 从上到下和从下到上
            int flag = 0;
            for(int i = 0; i < m; ++i){
                if(flag && h[i][j] == 0) h[i][j] = 1;
                if(h[i][j] == 2) flag = 1;
                if(h[i][j] == -1) flag = 0;
            }
            flag = 0;
            for(int i = m - 1; i >= 0; --i){
                if(flag && h[i][j] == 0) h[i][j] = 1;
                if(h[i][j] == 2) flag = 1;
                if(h[i][j] == -1) flag = 0;
            }
        }
        int ret = 0;
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                if(h[i][j] == 0) ++ret;
            }
        }
        return ret;
    }
};

Q4.逃离火灾

先对每个火源使用BFS，计算所有空地格最早被火蔓延时间。
然后对0和10^9二分，在每个时间条件下，对出发点进行BFS，看是否能够到达安全屋。
注意当到达安全屋的时候火正好蔓延到安全屋也算成功。

class Solution {
public:

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

    bool check(int time, vector<vector<int>>& grid, vector<vector<int>>& g){
        if(g[0][0] == 0) return false;
        int m = grid.size(), n = grid[0].size();
        vector<vector<int>> vis(m, vector<int> (n, 0));
        queue<pair<int, int>> q;
        q.push({0,0});
        vis[0][0] = 1;
        int t = 0;
        while(!q.empty()){
            int sz = q.size();
            while(sz--){
                int x = q.front().first, y = q.front().second;
                q.pop();
                for(int p = 0; p < 4; ++p){
                    int nx = x + dx[p], ny = y + dy[p];
                    if(nx == m - 1 && ny == n - 1 && g[nx][ny] >= t + time + 1) return true;
                    if(nx >= 0 && ny >= 0 && nx < m && ny < n && !vis[nx][ny] && g[nx][ny] > t + time + 1){
                        q.push({nx, ny});
                        vis[nx][ny] = 1;
                    }
                }
            }
            ++t;
        }
        return false;
    }

    int maximumMinutes(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size();
        vector<vector<int>> g(m, vector<int> (n, 0x6FFFFFFF));
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                if(grid[i][j] == 1) g[i][j] = 0;
                if(grid[i][j] == 2) g[i][j] = -1;
            }
        }
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                if(g[i][j] == 0){
                    vector<vector<int>> vis(m, vector<int> (n, 0));
                    queue<pair<int, int>> q;
                    q.push({i, j});
                    vis[i][j] = 1;
                    while(!q.empty()){
                        auto k = q.front();
                        q.pop();
                        int x = k.first, y = k.second;
                        for(int p = 0; p < 4; ++p){
                            int nx = x + dx[p], ny = y + dy[p];
                            if(nx >= 0 && ny >= 0 && nx < m && ny < n && !vis[nx][ny] && g[nx][ny] > g[x][y] + 1){
                                g[nx][ny] = g[x][y] + 1;
                                q.push({nx, ny});
                                vis[nx][ny] = 1;
                            }
                        }
                    }
                }
            }
        }

        int l = 0, r = 1000000000;
        if(!check(0, grid, g)) return -1;
        if(check(r, grid, g)) return r;
        while(l < r){
            int mid = (l + r) / 2;
            if(!check(mid, grid, g)) r = mid - 1;
            else l = mid + 1;
        }
        if(!check(l, grid, g)) return l - 1;
        return l;
    }
};