LeetCode 第 211 场周赛

A 两个相同字符之间的最长子字符串

模拟 枚举

class Solution {
public:
    int maxLengthBetweenEqualCharacters(string s) {
        int n = s.size();
        int ans = -1;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (s[i] == s[j]) {
                    ans = max(ans, j - i - 1);
                }
            }
        }
        return ans;
    }
};

B 执行操作后字典序最小的字符串

DFS + 剪枝

class Solution {
public:
    string ans;
    map<string, int> m;
    void dfs(string s, int a, int b) {
        if (m[s]) return ;
        m[s] = 1;
        ans = min(ans, s);
        string str = s;
        for (int i = 1; i < str.size(); i += 2) {
            int x = (str[i] - '0' + a) % 10;
            str[i] = (x + '0');
        }
        dfs(str, a, b);
        str = s.substr(s.size() - b, b) + s.substr(0, s.size() - b);
        dfs(str, a, b);
    }
    string findLexSmallestString(string s, int a, int b) {
        ans = s;
        dfs(s, a, b);
        return ans;
    }
};

C 无矛盾的最佳球队

先按年龄为第一优先级从小到大排序, 再按分数为第二优先级从小到大排序, 保证能形成分数递增, 把题目转换成最长递增子序列的题目, 再走下DP就好了

class Solution {
public:
    struct node{
        int scores, ages;
    }q;
    static bool cmp(node x, node y) {
        if (x.ages == y.ages) {
            return x.scores < y.scores;
        }
        return x.ages < y.ages;
    }
    int bestTeamScore(vector<int>& scores, vector<int>& ages) {
        int n = ages.size(), ans = 0;
        vector<node> p;
        vector<int> dp(n, 0);
        for (int i = 0; i < n; i++) {
            q.ages = ages[i];
            q.scores = scores[i];
            p.push_back(q);
        }
        sort(p.begin(), p.end(), cmp);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (p[j].scores <= p[i].scores) dp[i] = max(dp[i], dp[j]);
            }
            dp[i] += p[i].scores;
            ans = max(ans, dp[i]);
        }
        return ans;
    }
};

D 带阈值的图连通性

思考 + 并查集

class Solution {
public:
    int fi(int x, vector<int>& fa) {
        return x == fa[x] ? x : fa[x] = fi(fa[x], fa);
    }
    vector<bool> areConnected(int n, int threshold, vector<vector<int>>& queries) {
        vector<bool> ans;
        vector<int> fa(n + 1, 0);
        for (int i = 1; i <= n; i++) fa[i] = i;
        for (int i = threshold + 1; i <= n; i++) {
            for (int j = 2 * i; j <= n; j += i) {
                int fx = fi(i, fa), fy = fi(j, fa);
                if (fx != fy) fa[fx] = fy;    
            }
        }
        int m = queries.size();
        for (int i = 0; i < m; i++) {
            int fx = fi(queries[i][0], fa), fy = fi(queries[i][1], fa);
            ans.push_back(fx == fy);
        }
        return ans;
    }
};