Leetcode进阶之路——Biweekly Contest 4

这大概是打过最简单的一次leetcode…都不用赛后总结直接写博了
1118 Number of Days in a Month

给定年份Y和月份M，返回这一年这一月共有多少天
"难点"就是闰年二月的判断了，直接给代码：

class Solution {
public:
    int numberOfDays(int Y, int M) {
        if(M == 2)
        {
            if(Y % 400 == 0) return 29;
            else if(Y % 100 != 0 && Y % 4 == 0) return 29;
            return 28;
        }
        if((M < 8 && M % 2) || (M >= 8 && M % 2 == 0)) return 31;
        return 30;
    }
};

1119. Remove Vowels from a String
      
      给定一个字符串，从中删去所有的元音，返回删除后的字符串
      创建一个新字符串，遍历一遍，是元音的不添加即可

class Solution {
public:
    string removeVowels(string S) {
        map<char, int> m;
        m['a'] = 1, m['e'] = 1, m['i'] = 1, m['o'] = 1, m['u'] = 1;
        string res = "";
        for(char c: S)
        {
            if(m[c]) continue;
            res += c;
        }
        return res;
    }
};

1120. Maximum Average Subtree

给定一个二叉树，返回所有子树中，平均值最大的
递归遍历整棵二叉树，当 当前节点的子树平均值大于maxn，则更新

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    double maximumAverageSubtree(TreeNode* root) {
        double maxn = 0;
        helper(root, maxn);
        return maxn;
    }
    
    pair<int, int> helper(TreeNode* root, double& maxn)
    {
        if(root == NULL) return make_pair(0, 0);
        int val = root->val;
        pair<int, int> p = helper(root->left, maxn);
        val += p.first;
        pair<int, int> q = helper(root->right, maxn);
        val += q.first;
        int nodes = p.second + q.second + 1;
        if(val * 1.0 / nodes > maxn) maxn = val * 1.0 / nodes;
        return make_pair(val, nodes);
    }
};

1121. Divide Array Into Increasing Sequences
      
      这是一道披着hard外衣的easy题，给定一个整型数组和一个整数K，判断数组能否被拆分成若干子数组，满足所有子数组长度>=K，且子数组严格单调递增
      由于原数组是非减的，因此只要判断重复元素的个数即可，所有的重复元素必将被分到不同子数组中，则重复元素个数 * K 为原数组的最小长度，若原数组比该长度还小，则一定无法拆分

class Solution {
public:
    bool canDivideIntoSubsequences(vector<int>& nums, int K) {
        int maxn = 0;
        if(nums.size() == 1)
        {
            if(K == 1) return true;
            return false;
        }
        for(int i = 1; i < nums.size();)
        {
            if(nums[i] == nums[i - 1])
            {
                int cur = 1;
                while(i < nums.size() && nums[i] == nums[i - 1])
                {
                    cur++, i++;
                }
                maxn = max(maxn, cur);
            }
            else i++;
        }
        
        if(maxn * K > nums.size()) return false;
        return true;
    }
};