【LeetCode每日一题】——1235.规划兼职工作

一【题目类别】

• 排序

二【题目难度】

• 困难

三【题目编号】

• 1235.规划兼职工作

四【题目描述】

• 你打算利用空闲时间来做兼职工作赚些零花钱。
• 这里有 n 份兼职工作，每份工作预计从 startTime[i] 开始到 endTime[i] 结束，报酬为 profit[i]。
• 给你一份兼职工作表，包含开始时间 startTime，结束时间 endTime 和预计报酬 profit 三个数组，请你计算并返回可以获得的最大报酬。
• 注意，时间上出现重叠的 2 份工作不能同时进行。
• 如果你选择的工作在时间 X 结束，那么你可以立刻进行在时间 X 开始的下一份工作。

五【题目示例】

• 示例 1：
  

  • 输入：startTime = [1,2,3,3], endTime = [3,4,5,6], profit = [50,10,40,70]
  • 输出：120
  • 解释：
    • 我们选出第 1 份和第 4 份工作，
    • 时间范围是 [1-3]+[3-6]，共获得报酬 120 = 50 + 70。

• 示例 2：
  

  • 输入：startTime = [1,2,3,4,6], endTime = [3,5,10,6,9], profit = [20,20,100,70,60]
  • 输出：150
  • 解释：
    • 我们选择第 1，4，5 份工作。
    • 共获得报酬 150 = 20 + 70 + 60。

• 示例 3：
  

  • 输入：startTime = [1,1,1], endTime = [2,3,4], profit = [5,6,4]
  • 输出：6

六【题目提示】

• $1<=startTime.length==endTime.length==profit.length<=5\ast 10^4$
• $1<=startTime[i]<endTime[i]<=10^9$
• $1<=profit[i]<=10^4$

七【解题思路】

• 这道题目有点难，不过如果能想到使用动态规划就好做一些了
• 既然想要使用动态规划，就要写出动态转移方程，那么首先定义状态：dp[i]表示前i份工作可以获得的最大报酬。状态定义完毕后，我们需要考虑状态转移
  • 如果不选择当前工作，即jobs[i]，那么dp[i] = dp[i - 1]
  • 如果选择当前工作，那么就要保证上一个工作的时间点不能和当前选择的工作的时间点冲突，具体来说就是上一个工作的结束时间不能大于当前工作的开始时间，否则就存在重叠，无法正常工作。所以核心就是如何找到最接近当前工作的上一个工作，且不冲突，我们定义这样的工作为jobs[j]，那么需要满足jobs[j].end_time <= jobs[i].start_time，所以此时就有dp[i] = dp[j - 1] + jobs[i].profit
  • 综上，状态转移方程为dp[i] = max(dp[i -1], dp[j] + jobs[i].profit)
• 我们虽然搞定了状态转移方程，不过其中的j我们该如何确定呢？既然考虑的是j的工作结束时间和i的工作开始时间，所以我们只需要将原来的工作属性封装到一个数组中，并按工作结束时间从小到大进行排序，这样作为一个有序数组，就可以使用二分查找来定位我们需要的工作j，当然在二分查找的过程中，我们比较的原则是j的工作结束时间和i的工作开始时间
• 这样，我们就可以完美解决本题
• 大致思路如上，具体细节还请参考代码

八【时间频度】

• 时间复杂度：$O(nlogn)$，$n$为兼职工作的数量
• 空间复杂度：$O(n)$，$n$为兼职工作的数量

九【代码实现】

1. Java语言版

class Solution {
    public int jobScheduling(int[] startTime, int[] endTime, int[] profit) {
        int n = startTime.length;
        int[][] jobs = new int[n][3];
        for (int i = 0; i < n; i++) {
            jobs[i] = new int[]{startTime[i], endTime[i], profit[i]};
        }
        Arrays.sort(jobs, (a, b) -> a[1] - b[1]);
        int[] dp = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            int j = binarySearch(jobs, i - 1, jobs[i - 1][0]);
            dp[i] = Math.max(dp[i - 1], dp[j] + jobs[i - 1][2]);
        }
        return dp[n];
    }

    public int binarySearch(int[][] jobs, int right, int startTime) {
        int left = 0;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (jobs[mid][1] > startTime) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }

}

2. Python语言版

class Solution:
    def jobScheduling(self, startTime: List[int], endTime: List[int], profit: List[int]) -> int:
        n = len(startTime)
        jobs = sorted(zip(startTime, endTime, profit), key=lambda p : p[1])
        dp = [0] * (n + 1)
        for i in range(1, n + 1):
            j = bisect_right(jobs, jobs[i - 1][0], hi=i, key=lambda p : p[1])
            dp[i] = max(dp[i - 1], dp[j] + jobs[i - 1][2])
        return dp[n]

3. C语言版

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int binarySearch(const int jobs[][3], int right, int startTime)
{
    int left = 0;
    while (left < right)
    {
        int mid = left + (right - left) / 2;
        if (jobs[mid][1] > startTime)
        {
            right = mid;
        }
        else
        {
            left = mid + 1;
        }
    }
    return left;
}

int cmp(const void *pa, const void *pb)
{
    int *a = (int *)pa;
    int *b = (int *)pb;
    return a[1] - b[1];
}

int jobScheduling(int* startTime, int startTimeSize, int* endTime, int endTimeSize, int* profit, int profitSize)
{
    int n = startTimeSize;
    int jobs[n][3];
    for (int i = 0; i < n; i++)
    {
        jobs[i][0] = startTime[i];
        jobs[i][1] = endTime[i];
        jobs[i][2] = profit[i];
    }
    qsort(jobs, n, sizeof(jobs[0]), cmp);
    int dp[n + 1];
    memset(dp, 0, sizeof(dp));
    for(int i = 1; i <= n; i++)
    {
        int j = binarySearch(jobs, i - 1, jobs[i - 1][0]);
        dp[i] = MAX(dp[i - 1], dp[j] + jobs[i - 1][2]);
    }
    return dp[n];
}

十【提交结果】

1. Java语言版
   

2. Python语言版
   

3. C语言版