周赛补题

leetcode 单 ：  

第一题https://leetcode.cn/problems/convert-the-temperature/按题目要求模拟

class Solution {
public:
    vector<double> convertTemperature(double cel) {
        vector<double> ans;
        
        double x = cel + 273.15;
        ans.push_back(x);
        double y = cel * 1.8 + 32;
        ans.push_back(y);
        
        return ans;
    }
};

第二题https://leetcode.cn/problems/number-of-subarrays-with-lcm-equal-to-k/数据范围很小，可以直接暴力枚举

class Solution {
public:
    int subarrayLCM(vector<int>& nums, int k) {
        int sum = 0, zhon;
        int n = nums.size();
        
        for(int i = 0; i < n; i ++){
            for(int j = i + 1; j < n; j ++){
                if(j == i + 1)  zhon = nums[i];
                
                if(lcm(zhon, nums[j]) == k){
                    sum ++;
                    zhon = lcm(zhon, nums[j]);
                }else if(lcm(zhon, nums[j]) <= k){
                    zhon = lcm(zhon, nums[j]);
                }else  break;
                
            }
        }
        
        for(int i = 0; i < n; i ++){
            if(nums[i] == k)  sum ++;
        }
        
        return sum;
    }
};

第三题https://leetcode.cn/problems/minimum-number-of-operations-to-sort-a-binary-tree-by-level/description/大体思路还是很明确的，先递归遍历每一层，将每一层的数据用 vector 存储起来，最后找出每一层排好序的最小步骤，比赛时在最后一步出了问题，有点可惜

/**
 * 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:
    vector<vector<int>> res;

    int minimumOperations(TreeNode* root) {
        int idex = 0;
        res.resize(1e5);
        dfs(root, idex);
        
        int ans = 0;
        for(auto& c : res){
            ans += wsort(c);
        }
        
        return ans;
    }
    
    void dfs(TreeNode* root, int idex){
        res[idex].push_back(root -> val);
        if(!root -> left && !root -> right)  return ;
        
        if(root -> left != nullptr)  dfs(root -> left, idex + 1);
        if(root -> right != nullptr)  dfs(root -> right, idex + 1);
    }

    int wsort(vector<int>& x){
        vector<int> zhon = x;
        sort(zhon.begin(), zhon.end());
        
        unordered_map<int, int> w;
        for(int i = 0; i < zhon.size(); i ++)  w[zhon[i]] = i;

        int sum = 0;
        for(int i = 0; i < x.size(); i ++){
            while(x[i] != zhon[i]){
                swap(x[i], x[w[x[i]]]);
                sum ++;
            }
        }

        return sum;
    }
};

 leetcode 双 ： 

第一题https://leetcode.cn/problems/number-of-distinct-averages/description/ 排序加双指针即可，用 set 去重

class Solution {
public:
    int distinctAverages(vector<int>& nums) {
        unordered_set<double> ans;
        sort(nums.begin(), nums.end());
        int i = 0, j = nums.size() - 1;

        while(i < j){
            double x = (nums[i] + nums[j]) / 2.0;
            ans.insert(x);
            i ++;
            j --;
        }

        return ans.size();
    }
};

第二题https://leetcode.cn/problems/count-ways-to-build-good-strings/description/

首先考虑长度为 len 时的方案数。若 len≥zero, 则可以由长度为 len−zero 的方案数加上 zero 个 0. 当 len≥one 时同理，可以推出转移方程

class Solution {
    const int MOD = 1e9 + 7;

public:
    int countGoodStrings(int low, int high, int zero, int one) {
        long long f[high + 1];
        memset(f, 0, sizeof(f));
        f[0] = 1;

        for (int i = 1; i <= high; i++) {
            if (i >= zero) f[i] = (f[i] + f[i - zero]) % MOD;
            if (i >= one) f[i] = (f[i] + f[i - one]) % MOD;
        }

        long long ans = 0;
        for (int i = low; i <= high; i++) ans = (ans + f[i]) % MOD;

        return ans;
    }
};