LeetCode第266场周赛题解

2021.11.7第266场周赛

2062. 统计字符串中的元音子字符串

思路

暴力枚举所有连续子串，再用哈希表判断是否满足条件

代码

class Solution {
public:
    int countVowelSubstrings(string s) {
        int n = s.size();
        int ans = 0;
        for (int len = 5; len <= n; len ++ )
            for (int l = 0; l + len - 1 < n; l ++ ) {
                if (check(s, l, len))
                    ans ++ ;
            }
        return ans;
    }
    
    bool check(string& s, int l, int n) {
        unordered_set<char> se;
        for (int i = l; i < l + n; i ++ )
            if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' || s[i] == 'u') {
                se.insert(s[i]);
                if (se.size() > 5)
                    return false;
            }
            else
                return false;
        return se.size() == 5;
    }
};

2063. 所有子字符串中的元音

思路

枚举每个字符，如果当前字符是元音字母，则计算有多少连续子串包含该字符，设包含该字符的区间为[l, r]，当前字符下标i，则l和r的取值范围分别[0, i]，[i, n - 1]，总的组合数量为(i + 1) * (n - i)，依次计算并累加即可。

代码

class Solution {
public:
    long long countVowels(string s) {
        long long ans = 0;
        int n = s.size();
        for (int i = 0; i < n; i ++ ) {
            if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' || s[i] == 'u') {
                ans += 1ll * (i + 1) * (n - i);
            }
        }
        return ans;
    }
};

2064. 分配给商店的最多商品的最小值

思路

分配数量的最大值越大越能完成分配，具有二分性，可以二分出最大值。
检查某个最大值能否满足时，由于待分配的数量一定，假设每次均按最大值分配，若需要分配的组数小于商店数量，说明可以减少每个组分配的数量来增大组数使得组数满足条件，即最大值满足条件。

代码

class Solution {
public:
    int minimizedMaximum(int n, vector<int>& q) {
        int l = 1, r = 1e5;
        while (l < r) {
            int mid = l + r >> 1;
            if (check(mid, q, n)) r = mid;
            else l = mid + 1;
        }
        return l;
    }
    
    bool check(int x, vector<int>& q, int n) {
        int s = 0;
        for (int i : q) {
            s += (i - 1) / x + 1;
        }
        return s <= n;
    }
};

2065. 最大化一张图中的路径价值

思路

深度优先搜索
用领接表存储，从节点0开始搜索，当搜索的时间大于最大时间时剪枝
若当前点已走过则将价值记为0，回溯时恢复现场
注意答案最小为0号点的价值

代码

class Solution {
public:
    int ans;
    vector<vector<pair<int, int>>> g;
    vector<int> v;
    
    void dfs(int u, int time, int sum, int maxTime) {
        if (time > maxTime)
            return;
        if (u == 0) {
            ans = max(ans, sum);
        }
        for (int i = 0; i < g[u].size(); i ++ ) {
            int t = v[g[u][i].first];
            v[g[u][i].first] = 0;
            dfs(g[u][i].first, time + g[u][i].second, sum + t, maxTime);
            v[g[u][i].first] = t;
        }
    }
    
    
    int maximalPathQuality(vector<int>& _v, vector<vector<int>>& e, int maxTime) {
        int n = _v.size();
        v = _v;
        ans = v[0];
        g.resize(n, vector<pair<int, int>>());
        for (auto i : e) {
            g[i[0]].push_back({i[1], i[2]});
            g[i[1]].push_back({i[0], i[2]});
        }
        
        dfs(0, 0, 0, maxTime);
        
        return ans;
    }
};