LeetCode---389周赛

最新推荐文章于 2024-06-12 10:00:23 发布

竹下为生

最新推荐文章于 2024-06-12 10:00:23 发布

阅读量631

点赞数 25

分类专栏： LeetCode周赛文章标签： leetcode 算法职场和发展

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

版权

LeetCode周赛专栏收录该内容

51 篇文章 0 订阅

订阅专栏

题目列表

3083. 字符串及其反转中是否存在同一子字符串

3084. 统计以给定字符开头和结尾的子字符串总数

3085. 成为 K 特殊字符串需要删除的最少字符数

3086. 拾起 K 个 1 需要的最少行动次数

一、字符串及其反转中是否存在同一子字符串

直接暴力枚举即可，代码如下

class Solution {
public:
    bool isSubstringPresent(string s) {
        bool vis[26][26]={0};// vis[x][y] 表示(s[i-1],s[i])是否出现过
        for(int i=1;i<s.size();i++){
            int x = s[i-1]-'a',y = s[i]-'a';
            vis[x][y]=true;
            if(vis[y][x])
                return true;
        }
        return false;
    }
};

// 用位运算优化
class Solution {
public:
    bool isSubstringPresent(string s) {
        int vis[26]={0};
        for(int i=1;i<s.size();i++){
            int x = s[i-1]-'a',y = s[i]-'a';
            vis[x]|=(1<<y);
            if(vis[y]>>x & 1)
                return true;
        }
        return false;
    }
};

二、统计以给定字符开头和结尾的子字符串的总数

这题就是纯数学题，就是要求我们找出特定字符的个数，然后从中选出两个组成子字符串，这题单一字符也符合条件，所以答案为n*(n-1)/2+n，n表示字符串中特定字符的出现次数

代码如下

class Solution {
public:
    long long countSubstrings(string s, char c) {
        long long n = count(s.begin(),s.end(),c);
        return n*(n-1)/2+n;
    }
};

三、成为K特殊字符串需要删除的最少字符数

仔细读完题目，你会发现这题其实和字符没多大关系，关键是频率，思路如下：

首先我们用freq[26]统计各个字符出现的次数(即频率)，然后对freq进行排序，一共就26个字母的频率，我们可以暴力枚举以freq[i]为左端点，freq[i]+k为右端点的频率区间，在该区间内的字符不需要被修改，出现次数在该区间左边的字符要全被删除，出现次数在该区间右边的字符要被减少到freq[i]+k，枚举26次就能得到答案。

如何快速找到freq[i]+k对应的freq数组下标？用二分

如何快速得到前i个字符的出现次数？用前缀和

当然这题的freq数组不是很大，也就26个数，我们也可以直接遍历数组，不用二分+前缀和

代码如下

class Solution {
public:
    int minimumDeletions(string word, int k) {
        //统计频率
        int freq[26]={0};
        for(const auto&e:word)
            freq[e-'a']++;
        sort(freq,freq+26);
        int pre[27]={0};
        for(int i=0;i<26;i++) pre[i+1]=pre[i]+freq[i];
        int ans = INT_MAX;
        for(int i=0;i<26;i++){
            if(freq[i]==0) continue;
            int target=freq[i]+k;
            int l=i,r=25;
            while(l<=r){
                int m=l+(r-l)/2;
                if(freq[m]>target) r=m-1;
                else l=m+1;
            }
            ans=min(ans,pre[i]+pre[26]-pre[l]-target*(26-l));
        }
        return ans;
    }
};


class Solution {
public:
    int minimumDeletions(string word, int k) {
        int freq[26]={0};
        for(const auto&e:word)
            freq[e-'a']++;
        sort(freq,freq+26);
        int ans = 0;
        for(int i=0;i<26;i++){
            if(freq[i]==0) continue;
            int res = 0;
            for(int j=i;j<26;j++)
                res += min(freq[j],freq[i]+k);
            ans=max(ans,res);// 求能保持不变的最大字符数量
        }
        return word.size()-ans;
    }
};

四、拾起K个1需要的最少的行动次数

设 i 为Alice的站立位置的下标，j 为 1 所在位置下标

根据贪心，我们可以归纳出以下几个步骤(按照优先级排序)：

a、拿 i 左右两边的1（如果 i 左右是1的话）--- 只需行动 | i - j | = 1次

b、执行操作1将maxChanges个1放在 i 的左边/右边，再执行操作2，拿到1 --- 只需行动2次

c、执行操作2将被 i 附近的1拿到 --- 需要行动 | i - j | >= 2

(如果 i 本身就是1，那么不需要操作就直接拿到一个1，该行动在代码中与步骤a和并了，可以暂不考虑)

如果需要拿出的K个1可以在前两个步骤之内完成，可以直接计算出答案（具体看代码）

否则，我们在前两步得到的x个1的基础上，再得到 K - x 个1即可，很多人都会有这样的思维惯性，但是这样是不正确的，因为步骤a和步骤c是密切相关的，我们在得到x个1时，就已经确定了Alice的位置，但是这个位置不一定是最优的，因为它还会影响步骤c，所以我们应该把步骤a和步骤c放在一起考虑，步骤b的操作次数单独计算。

如何计算步骤a和步骤c得到的 K - maxChanges 个1需要的最少操作次数？

其实观察它们的表达是| i - j | 我们就能知道，我们要求的是 K - maxChanges 个1 到达某个位置的最短的距离和，用中位数贪心【中位数贪心的证明如下】

代码如下

class Solution {
public:
    long long minimumMoves(vector<int>& nums, int k, int maxChanges) {
        int n = nums.size();
        vector<int>pos;
        // 求连续1的个数
        int mx = 0;
        for(int i = 0; i < n; i++){
            if(nums[i]==0) continue;
            pos.push_back(i);//记录1出现的位置
            int j=i++;
            while(i<n&&nums[i]){
                pos.push_back(i);//记录1出现的位置
                i++;
            }
            mx=max(mx,i-j);
        }
        
        mx = min(3,min(k,mx));
        if(mx+maxChanges>=k)
            return max(mx-1,0)+(k-mx)*2LL;// 只用步骤a/步骤a+步骤b的操作次数

        int size = k - maxChanges; // 步骤a+步骤c需要的1的个数
        int m = pos.size();
        
        long long pre[m+1]; pre[0] = 0;
        for(int i = 0; i < m; i++) pre[i+1] = pre[i] + pos[i];

        long long ans = LLONG_MAX;
        for(int i = 0; i + size-1 < m; i++){
            int l = i, r = i + size - 1;
            int m = l + (r-l)/2;// pos[m]是中位数
            long long left = 1LL*(m-l)*pos[m]-(pre[m]-pre[l]);
            long long right = pre[r+1]-pre[m+1]-1LL*(r-m)*pos[m];
            ans = min(ans, left+right);
        }
        return ans+2LL*maxChanges;
    }
};