LeetCode --- 398周赛

最新推荐文章于 2024-07-12 18:12:33 发布

竹下为生

最新推荐文章于 2024-07-12 18:12:33 发布

阅读量508

点赞数 8

分类专栏： LeetCode周赛文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/V_zjs/article/details/139198292

版权

LeetCode周赛专栏收录该内容

52 篇文章 0 订阅

订阅专栏

题目列表

一、特殊数组I

遍历数组，看相邻元素的奇偶性是否相同即可，代码如下

class Solution {
public:
    bool isArraySpecial(vector<int>& nums) {
        int n = nums.size();
        for(int i = 1; i < n; i++){
            if((nums[i]+nums[i-1])%2==0) // 奇 + 偶 = 奇
                return false;
        }
        return true;
    }
};

二、特殊数组II

这一题是第一题的升级版，需要回答所给的询问的区间是否是特殊数组，如果每次询问都是遍历数组来判断是否满足条件，会超时。那么如何做？这里我们可以用前缀和来做，pre[i]用来记录前i个数中的相邻元素奇偶性相同的个数，给定区间[l，r]，我们就可以用pre[r]-pre[l]是否等于0来判断该区间内是否有相邻元素奇偶性相同的情况，代码如下

class Solution {
public:
    vector<bool> isArraySpecial(vector<int>& nums, vector<vector<int>>& queries) {
        int n = nums.size();
        vector<int> pre(n);
        for(int i=1;i<n;i++){
            pre[i] = pre[i-1] + (nums[i]%2==nums[i-1]%2);
        }
        int m = queries.size();
        vector<bool>ans(m);
        for(int i=0;i<m;i++){
            int l = queries[i][0], r = queries[i][1];
            ans[i] = pre[r] == pre[l];
        }
        return ans;
    }
};

三、所有数对中数位不同之和

这题就是统计，可以先统计出每一位上0-9出现的次数，然后在去分别计算每一位上数位不同的对数，求和就能得到答案，代码如下

// 两次遍历
class Solution {
public:
    long long sumDigitDifferences(vector<int>& nums) {
        int n = nums.size();
        int m = to_string(nums[0]).size(); // 计算是几位数
        vector<vector<int>> cnt(m,vector<int>(10));
        // 统计各个数位上0 - 9出现的次数
        for(auto x:nums){
            int k = 0;
            while(x){
                cnt[k++][x%10]++;
                x/=10;
            }
        }
        
        long long ans = 0;
        for(auto v:cnt){
            // 计算每个数位上不同的数对的个数，即使两层for暴力两两组合也能过(一共才10个数进行组合)
            long long pre = 0;
            for(auto x:v){
                ans += x*pre;
                pre += x;
            }
        }
        return ans;
    }
};


// 一次遍历
class Solution {
public:
    long long sumDigitDifferences(vector<int>& nums) {
        int n = nums.size();
        int m = to_string(nums[0]).size();
        vector<vector<int>> cnt(m,vector<int>(10));
        long long ans = 0;
        for(int i=0;i<n;i++){
            int x = nums[i];
            for(int k=0;x;x/=10,k++){
                ans += i - cnt[k][x%10]++;
            }
        }
        
        return ans;
    }
};

四、到达第K级台阶的方案数

这题我们可以用记忆化搜索来做，来暴力查找所有可能的情况。根据题目所给的条件，我们需要记录三个参数，分别为

i：代表当前数字为几
j：记录到目前为止操作2执行了多少次，下一次操作二，可以跳2^j
flag：用来表示上一次操作是操作一/操作二，0 - 操作1，1 - 操作2

递归方程：dfs(i,j,flag) = (flag ? dfs(i-1,j,0) : 0) + dfs(i+(1<<j)，j+1，1) + i==k

递归出口：当i>k && j>0时，flag = 0，则无法在往下走了，直接放回0，flag = 1，则可以往回退1个，返回 i-1==k

这题的时间复杂度其实很低，因为操作一不能连续使用，而操作二最多只能进行31次，所以我们的记忆化状态其实很少，具体是多少有兴趣的可以去算一算，下面给出大致的时间复杂度：

1 - m + 1+2^1+...+2^(j-1) = 2^j - m，其中m表示操作1的次数，j表示操作2的次数

如果2^j - m > k，递归退出，m相对于2^j可以直接忽略，所以2^j <= k => j <=logk，而操作一不能连续使用，所以最多也只能使用<=logk次，直接两两暴力组合一下，只有O((logk)^2)

代码如下

class Solution {
public:
    int waysToReachStair(int k) {
        // dfs(i,j,flag)
        // flag = 0 表示上一次操作为操作一
        // flag = 1 表示上一次操作为操作二
        unordered_map<long long,int> mp;
        function<int(int,int,int)>dfs=[&](int i,int j,int flag)->int{
            if(i>k && j>0) return flag?i-1==k:0; // 注意：i-1=k&&flag=1的情况
            long long mask = flag|j<<1|(long long)i<<32;
            if(mp.count(mask)) return mp[mask];
            int res = i==k;
            res += dfs(i+(1<<j),j+1,1); // 进行操作二
            if(flag) res += dfs(i-1,j,0); //进行操作一
            return mp[mask]=res;
        };
        return dfs(1,0,true);
    }
};