LeetCode第264场周赛题解

2021.10.24第264场周赛题解

2047. 句子中的有效单词数

思路

先用双指针找到每个用空格隔开的连续子串
接下来的目标就是判断每个子串是否是有效单词，具体看代码注释
p.s.这题属实搞心态，接近做了十几分钟还有几次wa

代码

class Solution {
public:
    int countValidWords(string s) {
        int n = s.size();
        int ans = 0;
        for (int i = 0; i < n;) {
            while (i < n && s[i] == ' ') i ++ ;
            if (i == n)
                break;
            int j = i;
            
            while (j < n && s[j] != ' ') j ++ ;
            
            //t是找出的子串
            string t = s.substr(i, j - i);
            bool f = true;
            int cnt = 0;
            for (char c : t) { //遍历一遍查找是否含有数字和记录-出现的次数
                if (isdigit(c))
                    f = false;
                if (c == '-')
                    cnt ++ ;
            }
            if (cnt > 1) //-出现大于1次不符合
                f = false;
            for (int k = 0; k < t.size() - 1; k ++ ) //标点不能出现的除了最后一位以外的位置
                if (t[k] == '.' || t[k] == '!' || t[k] == ',')
                    f = false;
            if (t.back() == '-' || t[0] == '-') //-不能出现在开始或结束
                f = false;
            int k = t.size() - 1;
            if (t[k] == '.' || t[k] == '!' || t[k] == ',') { //最后一位是标点 倒数第二位不能是-（这个极易忽略）
                t.pop_back();
                if (t.back() == '-')
                    f = false;
            }
            
            if (f)
                ans ++ ;
            i = j;
        }
        return ans;
    }
};

2048. 下一个更大的数值平衡数

思路

直接从n + 1开始枚举，知道找到第一个满足条件的数为止
p.s.check函数判断每个数位上的数字出现的次数时，只能用数组，用哈希表会tle，虽然时间复杂度都是O(1)，但是哈希表的效率更低，因为频繁的创建和销毁，以及使用哈希函数。可能卡常数了吧。

代码

class Solution {
public:
    int nextBeautifulNumber(int n) {
        for (int i = n + 1;; i ++ ) {
            if (check(i))
                return i;
        }
        return 0;
    }
    
    bool check(int x) {
        string s = to_string(x);
        vector<int> a(10, 0);
        for (auto c : s)
            a[c - '0'] ++ ;
        for (int i = 0; i < 10; i ++ ) {
            if (a[i] > 0 && a[i] != i)
                return false;
        }
        return true;
    }
};

2049. 统计最高分的节点数目

思路

去除一个点相邻的所有边后，会出现三个部分，左子树、右子树、其他
目标就是求出每个节点左右子树的节点的数量，其他用总结点数相减
首先通过深度优先遍历求出每个点的子节点的数量左子树节点的数量即左节点的子节点数量+1，右子树同理
进而求出每个节点的分数取最大后统计数量

代码

class Solution {
public:
    vector<int> d;
    
    void dfs(vector<vector<int>>& g, int cnt, int u) {
        if (g[u].size() == 0)
            d[u] == 0;
        if (g[u].size() > 0) {
            dfs(g, cnt + 1, g[u][0]);
            d[u] += d[g[u][0]] + 1;
        }
        if (g[u].size() > 1) {
            dfs(g, cnt + 1, g[u][1]);
            d[u] += d[g[u][1]] + 1;
        }
    }
    
    int countHighestScoreNodes(vector<int>& p) {
        int n = p.size();
        d.resize(n);
        vector<vector<int>> g(n, vector<int>(0));
        
        for (int i = 1; i < n; i ++ )
            g[p[i]].push_back(i);
        
        dfs(g, 0, 0);
        vector<int> l(n), r(n);
        vector<long long> b(n);
        long long m = 0;
        for (int i = 0; i < n; i ++ ) {
            long long t = 1;

            if (g[i].size() > 0) {
                l[i] = d[g[i][0]] + 1;
                t *= (long long)l[i];
            }
            if (g[i].size() > 1) {
                r[i] = d[g[i][1]] + 1;
                t *= r[i];
            }
            if (n - l[i] - r[i] - 1 != 0)
                t *= (n - l[i] - r[i] - 1ll);
            b[i] = t;
            m = max(m, t);
        }
        
        int ans = 0;
        for (long long i : b)
            if (i == m)
                ans ++ ;
        return ans;
    }
};

2050. 并行课程 III

思路

bfs求最短路
不同点是当某个点的距离可以变大时需要更新距离，因为要保证所有前导课程都已学完，以最后一次更新为准。

代码

class Solution {
public:
    int minimumTime(int n, vector<vector<int>>& r, vector<int>& time) {
        vector<int> dis(n + 1, 0);
        vector<int> d(n + 1);
        vector<vector<int>> g(n + 1, vector<int>());
        
        for (auto i : r) {
            d[i[1]] ++ ;
            g[i[0]].push_back(i[1]);
        }
        vector<int> st(n + 1);
        queue<int> q;
        for (int i = 1; i <= n; i ++ ) {
            if (d[i] == 0) {
                q.push(i);
                dis[i] = time[i - 1];
                st[i] = 1;
            }
        }
        
        while (q.size()) {
            int t = q.front();
            q.pop();
            st[t] = 0;
            for (int i = 0; i < g[t].size(); i ++ ) {
                int j = g[t][i];
                if (dis[j] < dis[t] + time[j - 1]) {
                    if(st[j] == 0) {
                        q.push(j);
                        st[j] = 1;
                    }
                    dis[j] = dis[t] + time[j - 1];
                }
            }
        }
        
        int ans = 0;
        for (int i = 1; i <= n; i ++ )
            ans = max(ans, dis[i]);
        
        return ans;
    }
};