LeetCode第343场周赛

2023.4.30LeetCode第343场周赛

A. 保龄球游戏的获胜者

思路

根据题意模拟

代码

class Solution {
public:
    int get(vector<int>& arr) {
        int res = 0;
        for (int i = 0; i < arr.size(); i ++ ) {
            res += arr[i];
            if (i && arr[i - 1] == 10 || i > 1 && arr[i - 2] == 10)
                res += arr[i];
        }
        return res;
    }

    int isWinner(vector<int>& player1, vector<int>& player2) {
        int a = get(player1);
        int b = get(player2);
        if (a > b) return 1;
        else if (a < b) return 2;
        return 0;
    }
};

B. 找出叠涂元素

思路

使用哈希表记录每个数出现的位置，再用m+n个集合记录每一行和每一列被涂满的格子数，若某行或某列全部被涂满则返回答案

代码

class Solution {
public:
    int firstCompleteIndex(vector<int>& arr, vector<vector<int>>& mat) {
        int n = mat.size(), m = mat[0].size();
        vector<unordered_set<int>> row(n), col(m);
        unordered_map<int, pair<int, int>> mp;
        for (int i = 0; i < n; i ++ )
            for (int j = 0; j < m; j ++ ) {
                mp[mat[i][j]] = {i, j};
            }
        for (int i = 0; i < arr.size(); i ++ ) {
            int x = mp[arr[i]].first, y = mp[arr[i]].second;
            row[x].insert(y);
            col[y].insert(x);
            if (row[x].size() == m || col[y].size() == n)
                return i;
        }
        return -1;
    }
};

C. 前往目标的最小代价

思路

BFS
首先将距离大于两点的曼哈顿距离的特殊路径去掉
每个点考虑经过每个特殊路径到达，分成两段，一段是当前点到特殊路径的起点，使用普通方式，另一段是特殊路径的起点到终点，使用特殊方式
若能更新最短距离，则加入队列继续更新其他点
每个点出队时，都和终点使用普通方式更新最短距离

代码

class Solution {
public:
    typedef pair<int, int> PII;
    
    int get(PII a, PII b) {
        return abs(a.first - b.first) + abs(a.second - b.second);
    }
    
    int minimumCost(vector<int>& start, vector<int>& target, vector<vector<int>>& specialRoads) {
        vector<vector<int>> a;
        for (auto x : specialRoads) {
            if (abs(x[2] - x[0]) + abs(x[3] - x[1]) > x[4])
                a.push_back(x);
        }
        queue<PII> q;
        map<PII, int> d;
        q.push({start[0], start[1]});
        d[{start[0], start[1]}] = 0;
        PII tar = {target[0], target[1]};
        d[tar] = get(tar, {start[0], start[1]});
        while (q.size()) {
            auto t = q.front();
            q.pop();
            d[tar] = min(d[tar], d[t] + get(tar, t));
            for (auto i : a) {
                int dis = d[t] + get(t, {i[0], i[1]}) + i[4];
                PII ed = {i[2], i[3]};
                if (!d.count(ed) || d[ed] > dis) {
                    d[ed] = dis;
                    q.push(ed);
                }
            }
        }
        
        return d[tar];
    }
};

D. 字典序最小的美丽字符串

思路

每次检查回文只用考虑前相邻一位和间隔一位是否相同，即如果不存在长度为2或3的回文串，就不存在长度2以上回文串
要使字典序尽量小，就尽量让右边的数位变大，当所有数位都满足不是回文串时直接返回

代码

class Solution {
public:
    string smallestBeautifulString(string s, int k) {
        int n = s.size();
        int i = n - 1; //从最右边开始考虑
        s[i] ++ ;
        while (i < n && i >= 0) {
            if (s[i] == 'a' + k) { //超出最高位
                if (i == 0) return ""; //此时已经是最左
                s[i] = 'a';
                s[ -- i] ++ ; //上一位进位
            } else if (i > 0 && s[i] == s[i - 1] || i > 1 && s[i] == s[i - 2]) { ///不满足回文
                s[i] ++ ;
            } else {
                i ++ ; //检查右边是否满足
            }
        }
        return s;
    }
};