标签：周赛 int 题解 long ++ vector ans LeetCode size

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;
    }
};

标签：周赛,int,题解,long,++,vector,ans,LeetCode,size
来源： https://blog.csdn.net/qq_44867112/article/details/120959857

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。