【模拟面试】#10 在既定时间做作业的学生人数解码方法最小的必要团队

最新推荐文章于 2022-03-31 15:30:00 发布

hanmin822

最新推荐文章于 2022-03-31 15:30:00 发布

阅读量169

点赞数

分类专栏：面试题试水

本文链接：https://blog.youkuaiyun.com/hanmin822/article/details/107361737

版权

面试题试水专栏收录该内容

20 篇文章

订阅专栏

题目1

给你两个整数数组 startTime（开始时间）和 endTime（结束时间），并指定一个整数 queryTime 作为查询时间。

已知，第 i 名学生在 startTime[i] 时开始写作业并于 endTime[i] 时完成作业。

请返回在查询时间 queryTime 时正在做作业的学生人数。形式上，返回能够使 queryTime 处于区间 [startTime[i], endTime[i]]（含）的学生人数。

示例 1：

输入：startTime = [1,2,3], endTime = [3,2,7], queryTime = 4
输出：1
解释：一共有 3 名学生。
第一名学生在时间 1 开始写作业，并于时间 3 完成作业，在时间 4 没有处于做作业的状态。
第二名学生在时间 2 开始写作业，并于时间 2 完成作业，在时间 4 没有处于做作业的状态。
第三名学生在时间 3 开始写作业，预计于时间 7 完成作业，这是是唯一一名在时间 4 时正在做作业的学生。

示例 2：

输入：startTime = [4], endTime = [4], queryTime = 4
输出：1
解释：在查询时间只有一名学生在做作业。

示例 3：

输入：startTime = [4], endTime = [4], queryTime = 5
输出：0

示例 4：

输入：startTime = [1,1,1,1], endTime = [1,3,2,4], queryTime = 7
输出：0

示例 5：

输入：startTime = [9,8,7,6,5,4,3,2,1], endTime = [10,10,10,10,10,10,10,10,10], queryTime = 5
输出：5

提示：

startTime.length == endTime.length
1 <= startTime.length <= 100
1 <= startTime[i] <= endTime[i] <= 100

思路及代码

简单题

class Solution {
public:
    int busyStudent(vector<int>& startTime, vector<int>& endTime, int queryTime) {
        int sum = 0;
        for(int i = 0;i < startTime.size();i++){
            if(queryTime >= startTime[i] && queryTime <= endTime[i]){
                sum++;
            }
        }
        return sum;
    }
};

题目2

一条包含字母 A-Z 的消息通过以下方式进行了编码：

'A' -> 1
'B' -> 2
...
'Z' -> 26

给定一个只包含数字的非空字符串，请计算解码方法的总数。

示例 1:

输入: "12"
输出: 2
解释: 它可以解码为 "AB"（1 2）或者 "L"（12）。

示例 2:

输入: "226"
输出: 3
解释: 它可以解码为 "BZ" (2 26), "VF" (22 6), 或者 "BBF" (2 2 6) 。

思路及代码

这道题用DP求解。在网上选了个稍微能看懂的代码。

本题假设给定的字符串为"s[1]s[2]……s[len]"，若我们用a[i-1]表示前i-1个字符的解码方法数，那么求解a[i]分为两步。第一，若第i个字符s[i]!='0'，那么第i个字符可以单独划分为一个字母，前i-1个字母的划分对其没有影响，即a[i] = a[i-1]；第二，若第i-1个字符和第i个字符可以组合成大于等于“10”，并且小于等于“26”的双字符，那么后两个字母组合一下，方法数为前i-2个字符的方法数，即a[i] = a[i] + a[i-2]。
原文链接：https://blog.youkuaiyun.com/jaster_wisdom/article/details/81148058

class Solution {
public:
    int numDecodings(string s) {
        int len = s.length();
        vector<int> vec(len+1);
        if(len==0 || s[0]=='0')
            return 0;
        vec[0] = 1;
        for(int i=1;i<len;i++){
            if(s[i]!='0')
                vec[i] = vec[i-1];
            if(s[i-1]=='1' || (s[i-1]=='2'&&s[i]>='0'&&s[i]<='6')){
                if(i==1)
                    vec[i] += 1;
                else
                    vec[i] += vec[i-2];
            }
        }
        return vec[len-1];
    }
};

题目3

作为项目经理，你规划了一份需求的技能清单 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<= req_skills.length <= 16，我们可以用“位”来表示是否拥有某项技能。

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

原文链接：https://blog.youkuaiyun.com/d5__j9/article/details/96003647

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;
    }
};

DP，一生之敌