【Leetcode第283场周赛】——周赛总结

1、6016. Excel 表中某个范围内的单元格 - 力扣（LeetCode） (leetcode-cn.com)

解法：模拟，没啥好说的

class Solution {
public:
    vector<string> cellsInRange(string s) {
        int n1=s[3]-s[0]+1;
        int n2=s[4]-s[1]+1;
        vector<string> ans;
        string t;
        string r;
        string q;
        for(int i=0;i<n1;i++){
            t=s[0]+i;
            for(int j=0;j<n2;j++){
                q=s[1]+j;
                r=t+q;
                ans.push_back(r);
            }
        }
        return ans;
    }
};

时间复杂度：O(n1*n2)；

2、6017. 向数组中追加 K 个整数 - 力扣（LeetCode） (leetcode-cn.com)

解法：排序后直接翻译题干就行了，也没啥好说的。就是代码细节有点多。还有该死的long long类型转换。

class Solution {
public:
    long long minimalKSum(vector<int>& nums, int k) {
        int n=nums.size();
        sort(nums.begin(),nums.end());
        long long slow=0,fast=1;
        long long res=0;
        int temp=k;
        if(nums[0]>1){
            if(nums[0]-1>=k){
                res+=(long long)((long long)(k+1)*k)/2;
                return res;
            }
            else{
                res+=(long long)((long long)nums[0]*(nums[0]-1))/2;
                temp=k-(nums[0]-1);
            }
        }
        for(fast;fast<n&&temp>0;fast++){
            if(nums[fast]-nums[slow]>1){
                if(nums[fast]-nums[slow]-1>=temp){
                    res+=(long long)((long long)(nums[slow]+1+nums[slow]+temp)*temp)/2;
                    break;
                }
                else{
                    res+=(long long)((long long)(nums[slow]+nums[fast])*(nums[fast]-nums[slow]-1))/2;
                    temp=temp-nums[fast]+nums[slow]+1;
                    slow++;
                }
            }
            else{
                slow++;
            }
        }
        if(temp>0&&fast==n)
            res+=(long long)((long long)(nums[n-1]+1+nums[n-1]+temp)*(temp))/2;
        return res;
    }
};

时间复杂度：O(nlog n)

 

鄙人菜鸡，周赛就写出两道题。以下两题为赛后所写：

3、6018. 根据描述创建二叉树 - 力扣（LeetCode） (leetcode-cn.com)

解法：1、根据题中所给的二叉树描述，我们可以使用一个hash表来储存树。key为结点的数据，value为结点指针。然后根据题目描述，我们遍历数组，将各父节点与子结点连接起来，形成一棵二叉树。

2、寻找根节点：再建一个hash表，首先统计一下各父结点在descriptions中出现的情况。然后再统计子结点的情况，将所有出现过子结点的位置置为0，那么最后再找到hash中value值为1的那个结点，就是根结点。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* createBinaryTree(vector<vector<int>>& descriptions) {
        unordered_map<int,TreeNode*> tree; //二叉树
        int n=descriptions.size();
        for(int i=0;i<n;i++){
            if(!tree[descriptions[i][0]]){  //父节点不存在，创建结点
                tree[descriptions[i][0]]=new TreeNode(descriptions[i][0]);
            }
            if(tree[descriptions[i][1]]){   //子结点存在
                if(descriptions[i][2]){
                    tree[descriptions[i][0]]->left=tree[descriptions[i][1]];
                }
                else{   
                    tree[descriptions[i][0]]->right=tree[descriptions[i][1]];
                }
            }
            else{       //子结点不存在
                TreeNode* t=new TreeNode(descriptions[i][1]);
                if(descriptions[i][2]){
                    tree[descriptions[i][0]]->left=t;
                }
                else{
                    tree[descriptions[i][0]]->right=t;
                }
                tree[descriptions[i][1]]=t;
            }
        }
        unordered_map<int,int> find;
        for(int i=0;i<n;i++){ //统计父节点
            find[descriptions[i][0]]++;
        }
        for(int i=0;i<n;i++){ //清除有父节点的结点频率
            find[descriptions[i][1]]=0;
        }
        for(int i=0;i<n;i++){
            if(find[descriptions[i][0]]){
                return tree[descriptions[i][0]];
            }
        }
        return nullptr;
    }
};

 时间复杂度：O(n)

4、6019. 替换数组中的非互质数 - 力扣（LeetCode） (leetcode-cn.com)

解法：用栈来模拟。数组当前元素进栈后，维持着题目中所要求的循环：取出栈顶两个元素，判断是否互质：如果不互质，求出最小公倍数，入栈，继续循环，直到栈空或者当前元素与后入栈的数组元素不互质，将元素再压入栈内，中断该循环。继续遍历下一数组元素。

class Solution {
public:
    vector<int> replaceNonCoprimes(vector<int>& nums) {
        int n=nums.size();
        stack<long long> s;
        s.push(nums[0]);
        for(int i=1;i<n;i++){
            s.push(nums[i]);
            while(1){
                long long first=s.top();
                s.pop();
                long long second;
                if(!s.empty()){ //栈中元素大于2
                    second=s.top(); //注意此时second仍在栈中
                }
                else{  //若取出当前栈顶元素first后，栈为空
                    s.push(first);
                    break;
                }
                if(gcd(first,second)>1){ //两数不互质，将最小公倍数算出并压入栈中
                    s.pop();
                    s.push(lcm(first,second));
                }
                else{ //两数互质，将已经取出的第一个元素压入栈内
                    s.push(first);
                    break;
                }
            }
        }

        vector<int> ans;
        while(!s.empty()){
            ans.emplace_back(s.top());
            s.pop();
        }
        reverse(ans.begin(),ans.end()); //倒序输出
        return ans;
    }

    long long gcd(long long a,long long b){ //辗转相除法求最大公约数
        return b==0?a:gcd(b,a%b);
    }
    long long lcm(long long a,long long b){ //最小公倍数
        return a*b/gcd(a,b);
    }
};

 任重而道远！