Leetcode进阶之路——Biweekly Contest 4

这大概是打过最简单的一次leetcode…都不用赛后总结直接写博了
1118 Number of Days in a Month
Leetcode进阶之路——Biweekly Contest 4_第1张图片
给定年份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;
    }
};
  1. Remove Vowels from a String
    Leetcode进阶之路——Biweekly Contest 4_第2张图片
    给定一个字符串,从中删去所有的元音,返回删除后的字符串
    创建一个新字符串,遍历一遍,是元音的不添加即可
class Solution {
public:
    string removeVowels(string S) {
        map 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;
    }
};
  1. Maximum Average Subtree

Leetcode进阶之路——Biweekly Contest 4_第3张图片给定一个二叉树,返回所有子树中,平均值最大的
递归遍历整棵二叉树,当 当前节点的子树平均值大于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 helper(TreeNode* root, double& maxn)
    {
        if(root == NULL) return make_pair(0, 0);
        int val = root->val;
        pair p = helper(root->left, maxn);
        val += p.first;
        pair 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);
    }
};
  1. Divide Array Into Increasing Sequences
    Leetcode进阶之路——Biweekly Contest 4_第4张图片
    这是一道披着hard外衣的easy题,给定一个整型数组和一个整数K,判断数组能否被拆分成若干子数组,满足所有子数组长度>=K,且子数组严格单调递增
    由于原数组是非减的,因此只要判断重复元素的个数即可,所有的重复元素必将被分到不同子数组中,则重复元素个数 * K 为原数组的最小长度,若原数组比该长度还小,则一定无法拆分
class Solution {
public:
    bool canDivideIntoSubsequences(vector& 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;
    }
};

你可能感兴趣的:(leetcode,C++,C++,leetcode)