LeetCode 第145周赛

LeetCode 第145周赛

第二题 最深叶节点的最近公共祖先

给你一个有根节点的二叉树，找到它最深的叶节点的最近公共祖先。

回想一下：

• 叶节点 是二叉树中没有子节点的节点
• 树的根节点的 深度 为 0，如果某一节点的深度为 d，那它的子节点的深度就是 d+1
• 如果我们假定 A 是一组节点 S 的 最近公共祖先，S 中的每个节点都在以 A 为根节点的子树中，且 A 的深度达到此条件下可能的最大值。

示例 1：

输入：root = [1,2,3]
输出：[1,2,3]

示例 2：

输入：root = [1,2,3,4]
输出：[4]

示例 3：

输入：root = [1,2,3,4,5]
输出：[2,4,5]

提示：

• 给你的树中将有 1 到 1000 个节点。
• 树中每个节点的值都在 1 到 1000 之间。

这题题目挺忽悠人的，其实就是找左右子树中最深的那个节点，如果左右子树高度都相同，则返回父节点即可

/**
 * 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:
    // 计算树的高度
    int height(TreeNode* root){
        if(root == NULL)
            return 0;
        return max(height(root->left), height(root->right)) + 1;
    }
    TreeNode* lcaDeepestLeaves(TreeNode* root) {
        if(root == NULL)
            return root;
        int h_left = height(root->left);
        int h_right = height(root->right);
        if(h_left == h_right) // 左右子树高度相同返回父节点
            return root;
        return h_left > h_right ? lcaDeepestLeaves(root->left) : 
        		lcaDeepestLeaves(root->right);
    }
};

第三题 表现良好的最长时间段：

你一份工作时间表 hours，上面记录着某一位员工每天的工作小时数。

我们认为当员工一天中的工作小时数大于 8 小时的时候，那么这一天就是「劳累的一天」。

所谓「表现良好的时间段」，意味在这段时间内，「劳累的天数」是严格 大于「不劳累的天数」。

请你返回「表现良好时间段」的最大长度。

示例 1：

输入：hours = [9,9,6,0,6,6,9]
输出：3
解释：最长的表现良好时间段是 [9,9,6]。

提示：

• 1 <= hours.length <= 10000
• 0 <= hours[i] <= 16

class Solution {
public:
    int longestWPI(vector<int>& hours) {
        // 题目意思是在给定的数组里找一个区间段，该区间内大于8的个数>小于等于8的个数
        // 其实就是大于8的个数大于区间长度的一半
        // 先统计好每个数（包括自己）之前有多少个大于8的，然后用区段的首尾作差和区段长度的一半进行比较即可
        int len = hours.size();
        int* sum = new int [len + 1];
        for(int i = 0;i < len; i++)
            sum[i + 1] = sum[i] + (hours[i] > 8 ? 1 : 0);
        for(int k = len;k > 0;k--)
            for(int i = len;i - k >= 0;i--)
                if(sum[i] - sum[i - k] > k / 2) return k;
        return 0;
    }
};

第四题 最小的必要团队

作为项目经理，你规划了一份需求的技能清单 req_skills，并打算从备选人员名单 people 中选出些人组成一个「必要团队」（ 编号为 i 的备选人员 people[i] 含有一份该备选人员掌握的技能列表）。

所谓「必要团队」，就是在这个团队中，对于所需求的技能列表 req_skills 中列出的每项技能，团队中至少有一名成员已经掌握。

我们可以用每个人的编号来表示团队中的成员：例如，团队 team = [0, 1, 3] 表示掌握技能分别为 people[0]，people[1]，和 people[3] 的备选人员。

请你返回 任一 规模最小的必要团队，团队成员用人员编号表示。你可以按任意顺序返回答案，本题保证答案存在。

示例 1：

输入：req_skills = ["java","nodejs","reactjs"], people = [["java"],["nodejs"],["nodejs","reactjs"]]
输出：[0,2]

示例 2：

输入：req_skills = ["algorithms","math","java","reactjs","csharp","aws"], people = [["algorithms","math","java"],["algorithms","math","reactjs"],["java","csharp","aws"],["reactjs","csharp"],["csharp","math"],["aws","java"]]
输出：[1,2]

提示：

• 1 <= req_skills.length <= 16
• 1 <= people.length <= 60
• 1 <= people[i].length, req_skills[i].length, people[i][j].length <= 16
• req_skills 和 people[i] 中的元素分别各不相同
• req_skills[i][j], people[i][j][k] 都由小写英文字母组成
• 本题保证「必要团队」一定存在

该题可以用二进制来表示每个人所具备的能力，要求的必要团队即当二进制全为1时，所用的最少人数的序列，因此可以采用dp来做

如例一，团队所需的技能为3个，则people可以表示为 people = [ [001], [010], [110] ] (001为java， 010 为nodejs， 100 为reactjs)，用一个dp数组来记录每种组合下的所需人数。

class Solution {
public:
    int dp[1 << 16];
    vector<int> res[1 << 16];
    map<string, int> mp;
    vector<int> smallestSufficientTeam(vector<string>& req_skills, vector<vector<string>>& people) {
        int m = req_skills.size(), n = people.size();   
        for(int i = 0; i < m; i++)
            mp[req_skills[i]] = i; //给skill编号
        
        int limit = 1 << m;
        memset(dp, -1, sizeof(dp));
        dp[0] = 0; res[0].clear();
        
        for(int i = 0; i < n; i++){
            int sk = 0;
            for(string& str: people[i]) sk |= (1 << mp[str]); // 某个人的技能二进制
            for(int j = 0; j < limit; j++){
                if(dp[j] == -1) continue;
                int next = j | sk;
                if(dp[next] == -1 || dp[j] + 1 < dp[next]){
                    dp[next] = dp[j] + 1;
                    res[next] = res[j];
                    res[next].push_back(i);
                }
            }
        }
        
        return res[limit - 1];
    }
};