LeetCode第348场周赛

LeetCode第348场周赛2023.6.4

A. 最小化字符串长度

思路

相同的字母都会被消掉，最后剩下一个

代码

class Solution {
public:
    int minimizedStringLength(string s) {
        unordered_set<char> a;
        for (char c : s)
            a.insert(c);
        return a.size();
    }
};

B. 半有序排列

思路

找到1和n的位置，将它们分别交换到第一个位置和最后一个位置
如果会互相交换，操作次数减1

代码

class Solution {
public:
    int semiOrderedPermutation(vector<int>& nums) {
        int n = nums.size();
        int a = 0, b = 0;
        for (int i = 0; i < n; i ++ ) {
            if (nums[i] == 1) a = i;
            if (nums[i] == n) b = i;
        }
        if (a < b) return a + (n - 1 - b);
        else return a + (n - 1 - b) - 1;
    }
};

C. 查询后矩阵的和

思路

倒序遍历查询数组，由于前面的操作都会被覆盖，故只用倒序遍历最后一次的操作，遍历过程中记录已经修改的行和列，计算每次受影响的格子数量

代码

class Solution {
public:
    typedef long long ll;
    
    long long matrixSumQueries(int n, vector<vector<int>>& queries) {
        ll ans = 0;
        unordered_set<int> row, col;
        for (int i = queries.size() - 1; i >= 0; i -- ) {
            auto x = queries[i];
            if (x[0] == 0) {
                if (!row.count(x[1])) {
                    row.insert(x[1]);
                    ans += (ll)(n - (ll)col.size()) * x[2];   
                }
            }
            else if (x[0] == 1) {
                if (!col.count(x[1])) {
                    col.insert(x[1]);
                    ans += (ll)(n - (ll)row.size()) * x[2];
                }
            }
        }
        return ans;
    }
};

D. 统计整数数目

思路

数位DP
思路转载自：https://leetcode.cn/problems/count-of-integers/solution/shu-wei-dp-tong-yong-mo-ban-pythonjavacg-9tuc/

代码

class Solution {
public:
    const int mod = 1e9 + 7;
    vector<vector<int>> f;

    int dfs(int u, int sum, bool limit, string& s, int min_sum, int max_sum) {
        if (sum > max_sum) return 0;
        if (u == s.size()) return sum >= min_sum;
        if (!limit && f[u][sum] != -1) return f[u][sum];
        int res = 0;
        int up = limit ? s[u] - '0' : 9;
        for (int i = 0; i <= up; i ++ ) {
            res = (res + dfs(u + 1, sum + i, limit && i == up, s, min_sum, max_sum)) % mod;
        }
        if (!limit) f[u][sum] = res;
        return res;
    }

    int get(string& s, int min_sum, int max_sum) {
        int n = s.size();
        f.assign(n, vector<int>(min(n * 9, max_sum) + 1, -1));
        return dfs(0, 0, true, s, min_sum, max_sum);
    }

    int count(string num1, string num2, int min_sum, int max_sum) {
        int ans = get(num2, min_sum, max_sum) - get(num1, min_sum, max_sum);
        int sum = 0;
        for (auto c : num1) sum += c - '0';
        ans += sum >= min_sum && sum <= max_sum;
        return (ans + mod) % mod;
    }
};