LeetCode --- 412周赛

题目列表

3264. K 次乘运算后的最终数组 I

3266. K 次乘运算后的最终数组 II

3265. 统计近似相等数对 I

3267. 统计近似相等数对 II

一、K次乘预算后的最终数组 I & II

 I 数据范围比较小，可以暴力模拟，代码如下

class Solution {
public:
    vector<int> getFinalState(vector<int>& nums, int k, int multiplier) {
        int n = nums.size();
        while(k--){
            int pos = 0;
            for(int i = 1; i < n; i++){
                if(nums[pos] > nums[i])
                    pos = i;
            }
            nums[pos] *= multiplier;
        }
        return nums;
    }
};

II 的数据范围变大了，暴力会超时，需要优化，如何做？

这里我们需要找到一些规律：

1、假设数组nums中只有一个数字x，我们直接返回 x * multiplier ^ k

2、假设数组nums中有两个数字 x，y (x <= y)

1) x 太小(或者 k 太小 或者 multiplier 太小)，导致 x * multiplier ^ k < y

2) x 和 y 相近，x 乘以 m (m < k) 个的 multiplier 后，就会大于 y，即 x * multiplier ^ m > y，那么下一次 y * multiplier 一定大于  x * multiplier ^ m (我们对两边同除multiplier，可得y > x*multiplier^(m-1) 成立），所以后面的乘法操作就是这两个数字交替进行。

3、假设数组nums中有三个数字 x，y，z (x <= y <= z)，当 z 成为最小值，x 变成 X，y变成Y 时，假设 z <= Y <= X，由 2 可知，z * multiplier 必然大于 Y 和 X，下一个 Y * multiplier 必然大于 z，下一个 X * multiplier 必然大于 Y，同理后面的乘法操作就是这三个数字交替进行。

......

我们不难得出结论：当数组中的最大值成为最小值的时候，剩余的 操作次数 会被均匀的分配给每个数字，如果除不尽的化，会按照大小顺序分配多余的1次乘法操作

那么在数组中的最大值成为最小值之前的操作，我们只需要模拟即可，代码如下

class Solution {
    const int MOD = 1e9 + 7;
    using LL = long long;
public:
    LL POW(LL x, LL y){
        LL res = 1;
        while(y){
            if(y & 1) res = (res * x) % MOD;
            x = (x * x) % MOD;
            y >>= 1; 
        }
        return res;
    }
    vector<int> getFinalState(vector<int>& nums, int k, int multiplier) {
        if(multiplier == 1) return nums;
        int n = nums.size();
        int mx = ranges::max(nums);
        priority_queue<pair<LL,int>,vector<pair<LL,int>>,greater<>>pq;
        // 建堆
        for(int i = 0; i < n; i++)
            pq.emplace(nums[i], i);
        // while循环的时间复杂度，考虑最坏情况 k = 1e9 ，muiliplier = 2
        // nums = {1，1，1，1，...，1e9}, U = max(nums), n = len(nums)
        // 即每一个 1 都需要 logU 的时间变得 >= 1e9
        // 时间复杂度为 min(k, nlognlogU) = nlognlogU
        while(k && mx != pq.top().first){
            auto [x, i] = pq.top(); pq.pop();
            pq.emplace(x * multiplier, i);
            k--;
        }
        int j = 0;
        int p1 = POW(multiplier, k/n) % MOD;
        int p2 = POW(multiplier, k/n + 1) % MOD;
        while(pq.size()){
            auto [x, i] = pq.top(); pq.pop();
            nums[i] = x % MOD * (j < k % n ? p2 : p1) % MOD;
            j++;
        }
        return nums;
    }
};

二、统计近似相等数对 I

题目一数据范围比较小，可以直接暴力模拟，代码如下

class Solution {
public:
    int countPairs(vector<int>& nums) {
        int n = nums.size(), ans = 0;
        auto check = [&](int i, int j)->bool{
            int x = nums[i], y = nums[j], ret = 0;
            int cnt1[10]{}, cnt2[10]{};
            while(x || y){
                if(x % 10 != y % 10){
                    cnt1[x % 10]++;
                    cnt2[y % 10]++;
                    ret++;
                }
                x /= 10, y /= 10;
            }
            for(int i = 0; i < 10; i++)
                if(cnt1[i] != cnt2[i])
                    return false;
            return ret == 0 || ret == 2;
        };
        for(int i = 0; i < n; i++){
            for(int j = i + 1; j < n; j++){
                ans += check(i, j);
            }
        }
        return ans;
    }
};

三、统计近似相等数对 II

这种找匹配个数的题，很容易想到两数之和，用哈希表，边记录数字出现次数，边统计结果，这题也是同理，我们边记录数字出现次数，边统计当前遍历到的数字能变成哪些数字，在将这些数字的出现次数加入答案即可，代码如下

class Solution {
public:
    int countPairs(vector<int>& nums) {
        ranges::sort(nums);
        int ans = 0;
        unordered_map<int,int>mp;
        for(int x: nums){
            unordered_set<int> st = {x}; // 记录 x 能变成哪些数字
            string s = to_string(x);
            int m = s.size();
            for(int i = 0; i < m; i++){
                for(int j = i + 1; j < m; j++){
                    swap(s[i], s[j]);
                    st.insert(stoi(s));
                    for(int p = i + 1; p < m; p++){
                        for(int q = p + 1; q < m; q++){
                            swap(s[p], s[q]);
                            st.insert(stoi(s));
                            swap(s[p], s[q]); // 注意要恢复现场
                        }
                    }
                    swap(s[i], s[j]); // 注意要恢复现场
                }
            }
            for(auto e: st)
                ans += (mp.contains(e) ? mp[e] : 0);
            mp[x]++;
        }
        return ans;
    }
};