Leetcode---361周赛

最新推荐文章于 2024-08-23 11:46:54 发布

竹下为生

最新推荐文章于 2024-08-23 11:46:54 发布

阅读量409

点赞数 1

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

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

版权

LeetCode周赛专栏收录该内容

58 篇文章 0 订阅

订阅专栏

题目列表

一、统计对称整数的数目

这题看一眼数据范围，直接就可以开始暴力求解了，按照题目要求模拟就行，代码如下

class Solution {
public:
    int countSymmetricIntegers(int low, int high) {
        int ans=0;
        for(int i=low;i<=high;i++){
            string s=to_string(i);
            if(s.size()%2)continue;
            int m=s.size()/2;
            int diff=0;
            for(int j=0;j<m;j++)
                diff+=(s[j]-s[j+m]);
            if(diff==0)ans++;
        }
        return ans;
    }
};

二、生成特殊数字的最小操作数

这题其实也不难，只要知道25的倍数的特点就行，即末尾两位为00，25 ，50，75的数字，题目要求最小操作数，就是在这四种情况中找到操作数最小的，当然还要注意0也能被25的整除，所以当不满足前面四种情况时，还要考虑数字中是否包含0，如果有返回n-1，如果没有返回n。

代码如下

class Solution {
public:
    int minimumOperations(string num) {
        int n=num.size();
        function<int(string)>f=[&](string s)->int{
            size_t pos=num.rfind(s[1]);
            if(pos==-1||pos==0)return n;
            pos=num.rfind(s[0],pos-1);
            if(pos==-1)return n;
            return n-pos-2;
        };
        int ret1=min(min(f("00"),f("25")),min(f("75"),f("50")));
        int ret2=n-(num.find('0')!=-1);
        return min(ret1,ret2);
    }
};

三、统计趣味子数组的数目

求满足条件的子数组的数量，一般都是用前缀和+哈希表，这题前缀和是求满足nums[i]%modulo=k的子数组的数量，这里有一些求余运算的数学知识，如下

假设s[ ]为前缀和数组，i<j，且(s[j]-s[i])%m=k，

那么s[j]%m-s[i]%m=k，即s[i]%m=s[j]%m-k，这里有一个细节要注意，s[j]%m-s[i]%m可能小于0，这样就需要+m之后再%m，才能得到正确的取模值，即s[j]%m-s[i]%m+m=k，s[i]%m=s[j]%m-k+m

综上所诉：无论s[j]%m-s[i]%m结果是正是负，s[i]%m=(s[j]%m-k+m)%m

所以，哈希表只用记录s%m之后的值的数量即可

代码如下

class Solution {
public:
    long long countInterestingSubarrays(vector<int>& nums, int m, int k) {
        long long ans=0;
        int s=0;
        unordered_map<int,int>hash;
        hash[0]=1;//这里要注意！！！，代表没有元素时，余数为0的情况
        for(auto x:nums){
            s+=(x%m==k);
            s%=m;
            ans+=hash[(s-k+m)%m];
            hash[s%m]++;
        }
        return ans;
    }
};

四、边权重均等查询

思路如下：

代码如下

class Solution {
public:
    vector<int> minOperationsQueries(int n, vector<vector<int>>& edges, vector<vector<int>>& queries) {
        //创建矩阵--记录每个点所连接的点和权值
        vector<vector<pair<int,int>>>g(n);
        for(auto& e:edges){
            int x=e[0],y=e[1],w=e[2]-1;
            g[x].push_back({y,w});
            g[y].push_back({x,w});
        }

        int m=32-__builtin_clz(n);//得到前导0的个数
        int cnt[n][m][26];
        memset(cnt,0,sizeof(cnt));
        int pa[n][m];
        memset(pa,-1,sizeof(pa));
        vector<int>depth(n);//记录每个点的深度
        function<void(int,int)> dfs=[&](int x,int father){
            pa[x][0]=father;
            for(auto [y,w]: g[x]){
                if(y!=father){
                    cnt[y][0][w]=1;
                    depth[y]=depth[x]+1;
                    dfs(y,x);
                }
            }
        };
        dfs(0,-1);

        //倍增
        for(int i=1;i<m;i++){
            for(int j=0;j<n;j++){
                int p=pa[j][i-1];
                if(p!=-1){
                    pa[j][i]=pa[p][i-1];
                    for(int k=0;k<26;k++){
                        cnt[j][i][k]=cnt[j][i-1][k]+cnt[p][i-1][k];
                    }
                }
            }
        }

        vector<int> ans;
        for(auto&e:queries){
            int a=e[0],b=e[1];
            int len=depth[a]+depth[b];
            if(depth[a]>depth[b])
                swap(a,b);
            int cw[26]{};

            //让x和y在同一高度
            for(int k=depth[b]-depth[a];k;k&=k-1){
                int idx=__builtin_ctz(k);
                int p=pa[b][idx];
                for(int j=0;j<26;j++)
                    cw[j]+=cnt[b][idx][j];
                b=p;
            }

            //同时向上跳
            if(a!=b){
                for(int i=m-1;i>=0;i--){
                    int A=pa[a][i],B=pa[b][i];
                    if(A!=B){
                        for(int k=0;k<26;k++){
                            cw[k]+=cnt[a][i][k]+cnt[b][i][k];
                        }
                        a=A,b=B;
                    }
                }
                //跳完之后，还在LAC下面一层
                for(int k=0;k<26;k++){
                    cw[k]+=cnt[a][0][k]+cnt[b][0][k];
                }
                a=pa[a][0];
            }
            int lca=a;
            len-=depth[lca]*2;
            ans.push_back(len-*max_element(cw,cw+26));
        }
        return ans;
    }
};