第 277 场周赛（模拟+数列求和+二叉树+最大公倍数/最小中约数/栈）

• 周赛地址

1.模拟

class Solution {
public:
    vector<string> cellsInRange(string s) {
        vector<string> ans;
        char c1 = s[0];
        char c2 = s[3];
        char n1 = s[1];
        char n2 = s[4];
        for(char c = c1; c <= c2; c++){
            for(char n = n1; n <= n2; n++){
                string temp = "";
                temp += c;
                temp += n;
                ans.push_back(temp);
            }
        }
        return ans;
    }
};

2.数列求和（首尾项求和公式）

class Solution {
public:
    long long minimalKSum(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end());
        
        int cnt = 0;

        long long ans = 0;
        
        nums.insert(nums.begin(), 0);
        int n = nums.size();
        for(int i = 1; i < n; i++){
            if(cnt >= k) break;
            
            int len = nums[i] - nums[i - 1] - 1;
            
            //cout << ans << " " << k - cnt << " " << len << endl;
            
            //cout << nums[i - 1] << " " << nums[i] << endl;
            if(nums[i - 1] + 1 == nums[i] || nums[i - 1] == nums[i]) continue;
            
            if(k - cnt >= len){
                //cout << "1 : "<< nums[i - 1] + 1 << " " << nums[i] - 1 << endl;
                ans += ((long long)nums[i - 1] + 1 + nums[i] - 1) * len / 2;
                
                cnt += len;
            }else{
                //cout << "2 : "<<nums[i - 1] + 1 << "" << nums[i - 1] + 1 + k - cnt - 1 << endl;
                ans += ((long long)nums[i - 1] + 1 + nums[i - 1] + 1 + k - cnt - 1) * (k - cnt) / 2;
                
                cnt += len;
            }
        }
        //cout << k - cnt << endl;
        if(cnt < k){
            ans += ((long long)nums[nums.size() - 1] + 1 + nums[nums.size()- 1] + 1 + k - cnt - 1) * (k - cnt) / 2;
        }
        return ans;
    }
};

3.构建二叉树

/**
 * 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>>& d) {
        unordered_map<int, TreeNode*> m;
        int n = d.size();
        for(int i = 0; i < n; i++){
            TreeNode* node = new TreeNode(d[i][1]);
            m[d[i][1]] = node;
        }
        TreeNode* head;
        for(int i = 0; i < n; i++){
            if(!m.count(d[i][0])){
                head = new TreeNode(d[i][0]);
                m[d[i][0]] = head;
                break;
            }
        }
        for(int i = 0; i < n; i++){
            TreeNode* f = m[d[i][0]];
            TreeNode* c = m[d[i][1]];
            if(d[i][2] == 1){
                f->left = c;
            }else{
                f->right = c;
            }
        }
        return head;
    }
};

4.最大公倍数/最小中约数/栈

• ab=最大公约数*最小公倍数

class Solution {
public:
    vector<int> replaceNonCoprimes(vector<int>& nums) {
        stack<int> s;

        int pre = nums[0];
        int n = nums.size();
        for(int i = 1; i < n; i++){
            if(gcd(pre, nums[i]) > 1){
                pre =  (long long)pre * nums[i] / gcd(pre, nums[i]);
            }else{
                while(!s.empty() && gcd(pre, s.top()) > 1){
                    pre = (long long) pre * s.top() / gcd(pre, s.top()) ;
                    s.pop();
                }
                s.push(pre);
                pre = nums[i];
            }
        }
        while(!s.empty() && gcd(pre, s.top()) > 1){
            pre = (long long)pre * s.top() /  gcd(pre, s.top());
            s.pop();
        }
        s.push(pre);

        vector<int> ans;
        while(!s.empty()){
            ans.push_back(s.top());
            s.pop();
        }
        reverse(ans.begin(), ans.end());
        return ans;

    }
};