LeetCode 1751. 最多可以参加的会议数目 II--二分+动态规划+贪心

1751. 最多可以参加的会议数目 II

给你一个 events 数组，其中 events[i] = [startDayi, endDayi, valuei] ，表示第 i 个会议在 startDayi 天开始，第 endDayi 天结束，如果你参加这个会议，你能得到价值 valuei 。同时给你一个整数 k 表示你能参加的最多会议数目。

你同一时间只能参加一个会议。如果你选择参加某个会议，那么你必须 完整 地参加完这个会议。会议结束日期是包含在会议内的，也就是说你不能同时参加一个开始日期与另一个结束日期相同的两个会议。

请你返回能得到的会议价值 最大和 。

示例 1：

输入：events = [[1,2,4],[3,4,3],[2,3,1]], k = 2
输出：7
解释：选择绿色的活动会议 0 和 1，得到总价值和为 4 + 3 = 7 。

示例 2：

输入：events = [[1,2,4],[3,4,3],[2,3,10]], k = 2
输出：10
解释：参加会议 2 ，得到价值和为 10 。
你没法再参加别的会议了，因为跟会议 2 有重叠。你 不 需要参加满 k 个会议。

示例 3：

输入：events = [[1,1,1],[2,2,2],[3,3,3],[4,4,4]], k = 3
输出：9
解释：尽管会议互不重叠，你只能参加 3 个会议，所以选择价值最大的 3 个会议。

提示：

1 <= k <= events.length
1 <= k * events.length <= 106
1 <= startDayi <= endDayi <= 109
1 <= valuei <= 106

题解

好的，理清下思路，如果没有要求只能参加K场会议，是不是就很简单了先贪心的按会议结束时间从小到大排序，然后不断存入数组，二分查找之前已经结束的会议，优化时间。
问题在于，控制了K场，其实也比较简单，我们进行循环，K场在K-1场的基础上去找答案即可。

AC代码

class Solution {
public:
    struct Node
    {
        int st,et,val;
    }a[1000010];
    static int cmp(Node a1,Node a2)
    {
        return a1.et<a2.et;//早点结束的排前面
    }
    int dp[1000010];
    vector<vector<int>>q;
    void Update(vector<int>t)
    {
        if(q.empty())
        q.push_back(t);
        else
        {
            int n=q.size()-1;
            while(q.size()>0&&q[n][0]>=t[0]&&q[n][1]<=t[1])
            {
                q.pop_back();
                n=q.size()-1;
            }
            if(q.empty())
            q.push_back(t);
            else if(q[n][0]<=t[0]&&q[n][1]<=t[1])
            q.push_back(t);
        }
    }
    int search(int st)
    {
        int l=0,r=q.size()-1,fin=-1;
        while(l<=r)
        {
            int mid=(l+r)/2;
            if(q[mid][0]<st)
            {
                l=mid+1;
                fin=mid;
            }
            else r=mid-1;
        }
        if(fin==-1)return 0;
        return q[fin][1];
    }
    int maxValue(vector<vector<int>>& events, int k) 
    {
        int n=events.size();
        for(int i=0;i<n;i++)
        {
            a[i].st=events[i][0];
            a[i].et=events[i][1];
            a[i].val=events[i][2];
        }
        sort(a,a+n,cmp);
        for(int i=0;i<n;i++)//只安装了一个会议的情况
            dp[i]=a[i].val;
        for(int i=2;i<=k;i++)
        {
            q.clear();
            for(int j=0;j<n;j++)//重新装入数组
            {
                vector<int>t;
                t.push_back(a[j].et);
                t.push_back(dp[j]);
                //cout<<a[j].et<<" "<<dp[j]<<endl;
                Update(t);
            }
            //for(int j=0;j<q.size();j++)
            //cout<<q[j][0]<<" "<<q[j][1]<<endl;
            for(int j=0;j<n;j++)//在已经参与了i-1场会议的基础上去找答案
            {
                int back=search(a[j].st);
                vector<int>t;
                dp[j]=back+a[j].val;
                //cout<<i<<" "<<j<<" "<<back<<endl;
            }
        }
        int res=0;
        for(int i=0;i<n;i++)
        res=max(res,dp[i]);
        return res;
    }
};

有点慢，，，，，算了，过了就行了