【2022/05/04-第283场单周赛】复盘

总结

服务器抽风了，全球排名应该是1091。Q2想搞点骚操作，结果想复杂了，最后一题因为网络多了两个WA。

Q1.Excel 表中某个范围内的单元格

直接两个循环。

class Solution {
public:
    vector<string> cellsInRange(string s) {
        vector<string> ret;
        for(char i = s[0]; i <= s[3]; ++i){
            for(char j = s[1]; j <= s[4]; ++j){
                ret.push_back({i, j});
            }
        }
        return ret;
    }
};

Q2.向数组中追加 K 个整数

一开始想着骚操作，从1-n+k删除数字，然后完全搞不出来。其实简单的模拟即可。

class Solution {
public:
    long long minimalKSum(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end());
        long long ret = 0, pre = 0;
        for(int i = 0; i < nums.size(); ++i){
            long long now = nums[i], num = nums[i] - pre - 1;
            if(num > 0 && k >= num){
                ret += (pre + now) * num / 2;
                k -= num;
            }
            else if(num > 0 && k < num){
                ret += (pre + 1 + pre + k) * k / 2;
                k = 0;
            }
            pre = now;
            if(!k) break;
        }
        if(k) ret += (pre + 1 + pre + k) * k / 2;
        return ret;
    }
};

Q3.根据描述创建二叉树

用值为pair的哈希表存储每个结点左右孩子的值，值为0代表空结点。
用哈希找到根结点，然后递归实现树。

class Solution {
public:
    unordered_map<int, pair<int, int>> mp;
    unordered_set<int> child;

    TreeNode* helper(int root){
        if(!root) return nullptr;
        TreeNode* ret = new TreeNode(root);
        ret->left = helper(mp[root].first);
        ret->right = helper(mp[root].second);
        return ret;
    }

    TreeNode* createBinaryTree(vector<vector<int>>& d) {
        for(auto i : d){
            child.insert(i[1]);
            if(i[2] == 1) mp[i[0]].first = i[1];
            else mp[i[0]].second = i[1];
        }
        int root;
        for(auto i : d){
            if(child.find(i[0]) == child.end()){
                root = i[0];
                break;
            }
        }
        return helper(root);
    }
};

Q4.替换数组中的非互质数

从前往后整一遍，然后从后往前整一遍，但是最后一个点过不了，多整一套就过了。

class Solution {
public:

    int gcd(int x, int y){
        if(x < y) swap(x, y);
        while(x % y){
            int t = y;
            y = x % y;
            x = t;
        }
        return y;
    }

    int lcm(int x, int y){
        return x / gcd(x, y) * y;
    }

    vector<int> replaceNonCoprimes(vector<int>& nums) {
        if(nums.size() == 1) return nums;
        vector<int> tnums;
        int temp = nums[0];
        for(int i = 1; i < nums.size(); ++i){
            if(gcd(temp, nums[i]) == 1){
                tnums.push_back(temp);
                temp = nums[i];
            }
            else temp = lcm(temp, nums[i]);
        }
        tnums.push_back(temp);
        if(tnums.size() == 1) return tnums;
        nums.clear();
        temp = tnums.back();
        for(int i = tnums.size() - 2; i >= 0; --i){
            if(gcd(temp, tnums[i]) == 1){
                nums.push_back(temp);
                temp = tnums[i];
            }
            else temp = lcm(temp, tnums[i]);
        }
        nums.push_back(temp);
        reverse(nums.begin(), nums.end());
        tnums.clear();
        temp = nums[0];
        for(int i = 1; i < nums.size(); ++i){
            if(gcd(temp, nums[i]) == 1){
                tnums.push_back(temp);
                temp = nums[i];
            }
            else temp = lcm(temp, nums[i]);
        }
        tnums.push_back(temp);
        if(tnums.size() == 1) return tnums;
        nums.clear();
        temp = tnums.back();
        for(int i = tnums.size() - 2; i >= 0; --i){
            if(gcd(temp, tnums[i]) == 1){
                nums.push_back(temp);
                temp = tnums[i];
            }
            else temp = lcm(temp, tnums[i]);
        }
        nums.push_back(temp);
        reverse(nums.begin(), nums.end());

        return nums;
    }
};