【2022-05-29-第295场单周赛】复盘

总结

第三题单调栈问题不够熟练。

Q1.重排字符形成目标字符串

哈希模拟。

class Solution {
public:
    int h1[26] = {0}, h2[26] = {0}, ret = INT_MAX;
    int rearrangeCharacters(string s, string tg) {
        for(auto &c : s) h1[c - 'a']++;
        for(auto &c : tg) h2[c - 'a']++;
        for(int i = 0 ; i < 26; ++i) if(h2[i]) ret = min(ret, h1[i] / h2[i]);
        return ret;
    }
};

Q2.价格减免

RATING:1577

比较麻烦的字符串模拟。

class Solution {
public:
    // 检查是否合法
    bool check(string &t){
        if(t.size() <= 1 || t[0] != '$') return false;
        for(int i = 1; i < t.size(); ++i) if(t[i] <'0' || t[i] > '9') return false;
        return true;
    }
    // 处理字符串
    string change(string &t, int di){
        if(!check(t)) return t; // 如果不是价格就不改了
        long long num = 0; string ret;
        // 字符串转long long
        for(int i = 1; i < t.size(); ++i)  num = num * 10 + t[i] - '0';
        // 直接乘以折扣，注意此时的num是以1/100元为单位的
        num *= (100 - di);
        string temp = "";
        if(num == 0) return "$0.00";
        while(num){
            temp += '0' + num % 10;
            num /= 10;
        }
        // num小于100时加前缀0
        if(temp.size() < 2) temp += "00";
        else if(temp.size() < 3) temp += '0';
        reverse(temp.begin(), temp.end()); // 要翻转字符串才是正确顺序
        ret = '$' + temp;
        ret.insert(ret.begin() + ret.size() - 2, '.'); // 插入小数点
        return ret;
    }
    
    string discountPrices(string se, int di) {
        string ret, temp;
        for(auto c : se){ // 遍历，分割字符串
            if(c == ' '){
                ret += change(temp, di) + ' ';
                temp.clear();
            }
            else temp += c;
        }
        ret += change(temp, di); // 因为结尾没有空格，别忘了最后一个字符串
        return ret;
    }
};

Q3.使数组按非递减顺序排列

RATING:2482

补完再更。

Q4.到达角落需要移除障碍物的最小数目

RATING:2138

0-1BFS。
双队列：

class Solution {
public:
    int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
    int minimumObstacles(vector<vector<int>>& g) {
        int m = g.size(), n = g[0].size();
        int vis[m][n];
        memset(vis, 0, sizeof(vis));
        queue<pair<int, int>> q;
        q.push({0, 0});
        vis[0][0] = 1;
        int d = -1;
        while(!q.empty()){
            ++d;
            int sz = q.size();
            while(sz--){
                queue<pair<int, int>> qq;
                auto [x, y] = q.front(); q.pop();
                for(int r = 0; r < 4; ++r){
                    int nx = x + dx[r], ny = y + dy[r];
                    if(nx >= 0 && ny >= 0 && nx < m && ny < n && !vis[nx][ny]){
                        if(g[nx][ny] == 1){
                            vis[nx][ny] = 1;
                            q.push({nx, ny});
                        }
                        else{
                            if(nx == m - 1 && ny == n - 1) return d;
                            vis[nx][ny] = 1;
                            qq.push({nx, ny});
                        }
                    }
                }

                while(!qq.empty()){
                    auto [x, y] = qq.front(); qq.pop();
                    for(int r = 0; r < 4; ++r){
                        int nx = x + dx[r], ny = y + dy[r];
                        if(nx >= 0 && ny >= 0 && nx < m && ny < n && !vis[nx][ny]){
                            if(g[nx][ny] == 1){
                                vis[nx][ny] = 1;
                                q.push({nx,ny});
                            }
                            else{
                                if(nx == m - 1 && ny == n - 1) return d;
                                vis[nx][ny] = 1;
                                qq.push({nx, ny});
                            }
                        }
                    }
                }
            }
        }
        return -1;
    }
};

双端队列：

class Solution {
public:
    int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
    int minimumObstacles(vector<vector<int>>& g) {
        deque<pair<int, int>> dq;
        int m = g.size(), n = g[0].size();
        int dis[m][n];
        for(int i = 0 ; i < m; ++i) for(int j = 0 ; j < n; ++j) dis[i][j] = INT_MAX;
        dis[0][0] = 0;
        dq.push_back({0, 0});
        while(!dq.empty()){
            auto [x, y] = dq.front(); dq.pop_front();
            for(int r = 0; r < 4; ++r){
                int nx = x + dx[r], ny = y + dy[r];
                if(nx >= 0 && ny >= 0 && nx < m && ny < n && dis[nx][ny] > g[nx][ny] + dis[x][y]){
                    dis[nx][ny] = g[nx][ny] + dis[x][y];
                    if(g[nx][ny] == 0) dq.push_front({nx, ny});
                    else dq.push_back({nx, ny});
                }
            }
        }
        return dis[m - 1][n - 1];
    }
};