LeetCode --- 418周赛

最新推荐文章于 2024-11-13 11:37:20 发布

竹下为生

最新推荐文章于 2024-11-13 11:37:20 发布

阅读量934

点赞数 31

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

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

版权

LeetCode周赛专栏收录该内容

67 篇文章 0 订阅

订阅专栏

题目列表

3309. 连接二进制表示可形成的最大数值

3310. 移除可疑的方法

3311. 构造符合图结构的二维矩阵

3312. 查询排序后的最大公约数

一、连接二进制表示可形成的最大值

这题由于数据范围很小，我们可以直接暴力枚举3! = 6种情况，取最大值，代码如下

class Solution {
public:
    int maxGoodNumber(vector<int>& nums) {
        auto get=[&](int x, int y, int z)->int{
            int cnty = 32 - __builtin_clz(y);
            int cntz = 32 - __builtin_clz(z);
            return (x << (cnty + cntz)) | (y << cntz) | z;
        };
        return max({get(nums[0], nums[1], nums[2]),
                    get(nums[0], nums[2], nums[1]),
                    get(nums[1], nums[0], nums[2]),
                    get(nums[1], nums[2], nums[0]),
                    get(nums[2], nums[1], nums[0]),
                    get(nums[2], nums[0], nums[1])});
    }
};

但如果nums.size()改为1e5，又该如何去做呢？思考二进制有点麻烦，我们可以先从十进制开始想，然后将规律迁移到二进制。比如给你22，32，3这三个数，如何拼接，得到的结果最大？也就是问哪个数放在前面，哪个数放在后面，很容易让人联想到排序，那么我们按照什么规律进行排序呢？即如何进行两个数的比较，而显然的是两个数a、b，只有两种排法，那么ab，那么ba，我们可以直接比较它们的大小，从而进行排序。

简单说明一下，为什么我们上面的排序好像只是比较了相邻两个数的顺序就能得出最优的拼接顺序，其实这有点类似冒泡排序（冒泡排序每次只是比较相邻的两个数就能让数组变得有序），或则我们可以用反正法来说明，如果最优顺序，和我们排序得到的顺序不同，那么最优序列必然存在相邻的两个数的关系是不满足递增或者递减性质的(这里的递增/递减规则是比较ab和ba的大小)，则最优顺序可以通过交换这两个数得到更优的顺序，故我们的排序得到的顺序就是最优的

代码如下

class Solution {
public:
    int maxGoodNumber(vector<int>& nums) {
        ranges::sort(nums, [](int a, int b){
            int len_a = __lg(a) + 1;
            int len_b = __lg(b) + 1;
            return ((a<<len_b)|b) > ((b<<len_a)|a);
        });
        int ans = 0;
        for(int x:nums){
            ans = (ans << (__lg(x) + 1) | x);
        }
        return ans;
    }
};

二、移除可以的方法

这题可以简单概括为，给你一个图，并告诉你一个结点，从该结点出发能到达的所有结点都是可疑结点，如果没有正常的结点指向可疑结点中的任何一个结点，就将可疑结点全部移除，返回剩余结点，否则返回所有结点。代码如下（ps：这题的唯一难点在于读懂题目意思。。。）

class Solution {
public:
    vector<int> remainingMethods(int n, int k, vector<vector<int>>& invocations) {
        vector<vector<int>> g(n); // 建图
        for (auto& e : invocations) {
            g[e[0]].push_back(e[1]);
        }
        vector<bool>vis(n); // 遍历所有可疑结点
        auto dfs = [&](auto&&dfs, int x)->void{
            vis[x] = true;
            for(int y:g[x]){
                if(!vis[y])
                    dfs(dfs, y);
            }
        };
        dfs(dfs, k);
        for(auto e:invocations){
            int x = e[0], y = e[1];
            if(!vis[x] && vis[y]){ // 查看是否存在正常结点指向可疑结点
               vector<int>ans(n);
               iota(ans.begin(), ans.end(), 0);
               return ans; 
            }
        }

        vector<int> ans;
        for(int i = 0; i < n; i++){
            if(!vis[i]){
                ans.push_back(i);
            }
        }
        return ans;
    }
};

三、构造符合图结构的二维矩阵

本题要求我们将图变成矩阵的形式(相邻的格子之间有边)。

如何构造这样的一个符合条件的矩形？显然的一点，我们可以通过每个点的入度/出度来判断出它所在的大致位置，如下

入度为1的结点，必然只在矩阵的两头，且该矩阵只有一行/只有一列
入度为2的结点，必然分布在矩阵的四个角上，且该矩阵的行数/列数>=2
入度为4的结点，必然分布在矩阵的中心，且该矩阵的行数和列数>=3

对于构造这样的一个矩形，只要我们将第一行的结点确定，那么它的下一行的结点也将会被确定，所以我们只要求出第一行的结点有哪些即可。

我们有如下三种情况需要分析讨论

1、如果矩阵只有一行，则图是一个链式的，直接遍历返回

2、如果矩阵只有两行

3、如果矩阵>=3行

代码如下

class Solution {
public:
    vector<vector<int>> constructGridLayout(int n, vector<vector<int>>& edges) {
        vector<int>indg(n);
        vector<vector<int>> g(n);
        for(auto& e : edges){
            int x = e[0], y = e[1];
            g[x].push_back(y);
            g[y].push_back(x);
            indg[x]++, indg[y]++;
        }
        unordered_map<int,vector<int>> mp;
        for(int i = 0; i < n; i++){
            mp[indg[i]].push_back(i);
        }

        vector<int> row; // 首行
        if(mp.count(1)){ // 矩阵只有一列
            row.push_back(mp[1][0]);
        }else if(mp.count(4) == 0){ // 矩阵只有两列
            row.push_back(mp[2][0]);
            for(auto x:g[row[0]]){
                if(indg[x] == 2){
                    row.push_back(x);
                    break;
                }
            }
        }else{ // 矩阵>=3列
            row.push_back(mp[2][0]);
            // 找2333...3332
            int pre = row[0];
            int x = g[pre][0];
            while(indg[x] == 3){
                row.push_back(x);
                for(int y : g[x]){
                    if(y != pre && indg[y] < 4){
                        pre = x, x = y;
                        break;
                    }
                }
            }
            row.push_back(x);
        }
        vector<bool> vis(n);
        for(auto x:row) vis[x] = true;
        vector<vector<int>>ans(n/row.size(), vector<int>(row.size()));
        ans[0] = row;
        for(int i = 1; i < n/row.size(); i++){
            for(int j = 0; j < row.size(); j++){
                for(int x:g[ans[i-1][j]]){ // 通过上一行的结点来判断下一行的结点
                    if(!vis[x]){
                        ans[i][j] = x;
                        vis[x] = true;
                        break;
                    }
                }
            }
        }
        return ans;
    }
};

四、查询排序后的最大公约数

本题让我们求出数组中任意两个数的最大公约数，进行排序，最后返回下标查询结果。

关键在于如何快速算出最大公约数？这里有一个思路技巧 --- 枚举公约数 x ，去看数组中有哪些数字是它的倍数，然后从中任取两个数C(2,n)，就能得出公约数为 x 的数对个数。但是有一个问题：假设我们有2，4，6，8，12这五个数，求gcd=2的数对有10个，但是其中4和8的最大公约数为4，6和12的最大公约数为6，8和12的最大公约数是4，它们都不应该被算进来，也就是说我们还需要减去以2k(k>1)的最大公约数的数对个数，才能得出最大公约数为2的数对个数

所以设dp[x]为最大公约数为 x 的数对个数，则dp[x] = C(n，2) - sum(dp[y]) ，其中y = kx，k>1，n为x的倍数出现的次数

代码如下

class Solution {
public:
    vector<int> gcdValues(vector<int>& nums, vector<long long>& queries) {
        unordered_map<int,int> mp;
        int mx = 0;
        for(auto x:nums){// 统计数字的频率 和 数字最大值
            mp[x]++; 
            mx = max(mx, x);
        }
        // f[i] 表示 以i为最大公约数的数对个数
        vector<long long> f(mx + 1);
        // 下面循环的时间复杂度为
        //   mx/1 + mx/2 + mx/3 + mx/4 + ... + mx/mx
        // = mx(1/1+1/2+1/3+...+1/mx)
        // = mx*logmx
        // 时间复杂度O(UlogU) U = mx
        for(int i = mx; i > 0; i--){
            long long c = 0;
            for(int j = i; j <= mx; j += i){
                if(mp.count(j)) c += mp[j];
                f[i] -= f[j];
            }
            f[i] += (c - 1) * c / 2;
        }
        // 将 f 变成前缀和数组
        for(int i = 1; i <= mx; i++){
            f[i] += f[i - 1];
        }
        vector<int> ans(queries.size());
        for(int i = 0; i < queries.size(); i++){
            auto j = upper_bound(f.begin(), f.end(), queries[i]) - f.begin();
            ans[i] = j;
        }
        return ans;
    }
};