规划兼职工作

题目链接：https://leetcode.cn/problems/maximum-profit-in-job-scheduling/
描述

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

输入

1 <= startTime.length == endTime.length == profit.length <= 5 * 10^4
1 <= startTime[i] < endTime[i] <= 10^9
1 <= profit[i] <= 10^4
例：startTime = [1,2,3,4,6], endTime = [3,5,10,6,9], profit = [20,20,100,70,60]

输出

150

思路：
PS：又是好久没写，过来水一发，传统手艺不能丢^ _ ^。
读完题感觉是个动态规划题，定义DP[ti]为[0,ti]时间段内获得的最大报酬(ti>=0)，Job[j].st、Job[j].et与Job[j].p分别为工作j的开始、结束时间和报酬。若ti时间工作j正好结束则DP[ ti ]=max( DP[ ti-1 ] ,DP[ Job[j].st ]+Job[j].p ])，否则DP[ ti ]=DP[ ti-1 ]，DP[0]=0。按照思路为了确保DP[ ti ]正确性，需要将所有工作按照结束时间升序排序，然后依次计算时间1至max( Job[j].et )内的最大报酬。
但是一看Job.et的最大值为1e9无论从时间还是空间复杂度上考虑，原本方案都是行不通的。考虑到当ti时刻没有工作结束时DP[ ti ]=DP[ ti-1 ]，因此可将连续的时间离散化，仅计算和记录每个工作结束时刻的最大报酬。设Ptj为能开始Job[j]的前一个工作的结束时间在离散时间序列中的位置(可通过二分查找完成Ptj的计算)，于是DP[ j ] = max( DP[ j-1 ] ,DP[ Ptj ]+Job[j].p)，DP[0]=0，其中1<=j<=n且工作序列Job已按照结束时间升序排。

const int Ms=5e4+5;
struct node
{
    int st,ed;
    int val;
    bool operator<(const node &o)const
    {
        if(ed!=o.ed)return ed<o.ed;
        return val>o.val;
    }
}job[Ms];
int Ed[Ms],dp[Ms];
class Solution {
public:
    int jobScheduling(vector<int>& startTime, vector<int>& endTime, vector<int>& profit) {
        int n=startTime.size();
        for(int i=0;i<n;i++)
        {
            job[i]=(node){startTime[i],endTime[i],profit[i]};
        }
        sort(job,job+n);
        int tot=1,pos;
        Ed[0]=dp[0]=0;
        for(int i=0;i<n;i++)
        {
            pos=lower_bound(Ed,Ed+tot,job[i].st)-Ed;
            if(pos==tot||Ed[pos]>job[i].st)pos--;
            if(dp[pos]+job[i].val>dp[tot-1])
            {
                dp[tot]=dp[pos]+job[i].val;
                Ed[tot]=job[i].ed;
                tot++;
            }
        }
        return dp[tot-1];
    }
};

若有什么错误，欢迎指正^ _ ^ 。