leetcode contest 145

一、1122. Relative Sort Array

这题很简单，按照题目要求写就好。

先用map对arr1中的元素计数然后按照arr2中元素的顺序构建答案数组。

class Solution {
public:
    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
        unordered_set<int> exist(arr2.begin(),arr2.end());
        unordered_map<int,int> cnt;
        int n=arr1.size(),m=arr2.size();
        vector<int> ans,res;
        for(int i=0;i<n;++i)
        {
            int num=arr1[i];
            if(exist.count(num))
                ++cnt[num];
            else
                ans.push_back(num);
        }
        for(int i=0;i<m;++i)
        {
            int k=cnt[arr2[i]];
            while(k>0)
                --k,res.push_back(arr2[i]);
        }
        sort(ans.begin(),ans.end());
        for(int i:ans)
            res.push_back(i);
        return res;
    }
};

二、1123. Lowest Common Ancestor of Deepest Leaves

这题要求“最深的”叶子的“最深”“公共”祖先。根节点深度为0，一个节点的子节点的深度为该节点深度+1。

这题如果看到了这个要点就可以迎刃而解了：最深公共祖先的特点就是该节点的左右子树一样高。

• 最深公共祖先包含了所有最深叶子，则不能推出其左右子树都一样高，因为其左右子树必定都含有最深叶子；
• 所只有一个子树含有最深叶子，则该节点不是我们要找的节点，其包含了最深叶子的那个子树的子树根节点才是我们要的；
• 最深公共祖先的父节点不会被判定为要求的节点，因为这个节点的一个子树包含了所有最深叶子节点，而另一个子树不包含任何最深叶子节点，所以左右子树的高度必定不一致。

由上述思路，我们自底向上，先找叶子，再确定最深叶子，然后往上早最深公共祖先——即左右子树高度一致的节点。

/**
 * 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:
    TreeNode* lcaDeepestLeaves(TreeNode* root) {
        int depth=0;
        return deep(root,depth);
    }
    //理解最深公共祖先的特点就是该节点的左右子树高度一样
    //DFS，自底向上
    TreeNode* deep(TreeNode* root,int& depth){
        depth=0;
        if(root==NULL)
            return root;
        int ld,rd;//ld=左子树高度,rd=右子树高度
        TreeNode* left=deep(root->left,ld);
        TreeNode* right=deep(root->right,rd);
        depth=max(ld,rd)+1;//当前子树的高度
        if(ld==rd)
            return root;
        return ld>rd?left:right;
    }
};

三、1124. Longest Well-Performing Interval

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

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

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

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

（看来以后都是劳累的一天了）

思路：

这题我想到了将工作时长大于8的一天标记为1，否则标记为-1，则将问题转换为求一个最长的连续区间使得区间中所有元素的和为正数。但我没想出该怎么做，参考了discuss大神的做法。

延续上述：

• 令sum=0，从第一天开始若一天的工作时长>8则sum+1，否则sum-1；
• 若sum大于0，则说明从第一天到当前这段时间都是“表现良好时段”；
• 若sum小于0，设j为当前的日期，则[0,j]这段时间不符合要求，我们要找一个符合要求的[i,j]区间，而[0,i]由[0,i]和[i,j]组成。由于sum每次都是加1或者减1。所以假设区间[i,j]的和为2，则区间[0,i]的和为sum-2，因为0>sum-1>sum-2，所以若区间0,i]的和为sum-2则必存在区间[0,k]的和为sum-1，且k<i。（因为sum每次都是加1或者减1），以此类推可知，取[0,i]的区间和为sum-1时[i,j]区间的长度最大。
• 据上述，我们记录每个sum第一次（为了保证上述的[i,j]区间最长）出现时的区间右端点。

class Solution {
public:
    int longestWPI(vector<int>& hours) {
        int sum=0,ans=0;
        unordered_map<int,int> record;
        for(int i=0;i<hours.size();++i)
        {
            sum+=(hours[i]>8?1:-1);
            if(sum>0)
                ans=i+1;
            else
            {
                if(record.count(sum-1))
                    ans=max(ans,i-record[sum-1]);
                if(record.count(sum)==0)
                    record[sum]=i;
            }
        }
        return ans;
    }
};

四、1125. Smallest Sufficient Team

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

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

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

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

• 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<= req_skills.length <= 16，我们可以用“位”来表示是否拥有某项技能。

• 首先将需要的技能映射为对应的位——给技能编号，如1001则说明需要0号技能和3号技能；
• 一个用于动态规划的数组——dp[i]，其中i表示拥有了哪些技能，dp[i]表示拥有这些技能需要的最小人数；
• 用一个vector<pair<int,int>>记录要选择哪些工人——其中first记录当前已拥有的技能，second记录当前选择的人；
• 最后根据上面的记录构建答案数组。

class Solution {
public:
    vector<int> smallestSufficientTeam(vector<string>& req_skills, vector<vector<string>>& people) {
        unordered_map<string,int> skills;
        for(int i=0;i<req_skills.size();++i)    //给每个需要的技能编号
            skills[req_skills[i]]=i;
        
        int n=req_skills.size();
        vector<int> dp(1<<n,-1);    //[技能]=最少人数
        vector<pair<int,int>> record(1<<n,{-1,-1});
        dp[0]=0;    //dp初始条件
        
        for(int i=0;i<people.size();++i)
        {
            int have=0; 
            for(string skill:people[i])     //people[i]掌握了哪些技能
                have|=(1<<(skills[skill]));
            
            for(int j=0;j<dp.size();++j)    
            {
                if(dp[j]==-1)
                    continue;
                int total=j|have;
                if(dp[total]==-1||dp[total]>dp[j]+1)    //dp[total]>dp[j]+1,则当前的选择比之前的选择需要的人数更少
                {
                    dp[total]=dp[j]+1;
                    //first记录路径,second记录选择哪一个人
                    record[total].first=j,record[total].second=i;
                }
            }
        }
        
        vector<int> ans;
        int need=(1<<n)-1;
        while(need!=0)  //0是上面保存的路径的尽头
            ans.push_back(record[need].second),need=record[need].first;
        return ans;
        
    }
};