【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 <= 10^6
  • 1 <= startDayi <= endDayi <= 10^9
  • 1 <= valuei <= 10^6

思路

题目给的events是无序的,可以先排序一下。

这道题类似于背包问题或最长上升子序列。

f[i][j] 表示 前i个会议中,参加最多j个,获得的最大收益。于是我们可以遍历每个会议,分别计算f[i][1...k]能获得的最大利润。

由于参加一个会议需要整个会议的时间,我们可以用当前会议开始的时间去匹配所有会议结束的时间,来查找最早可以开始的时间。这个过程可以使用二分搜索。
Cpp

cpp 复制代码
class Solution {  
public:  
    int maxValue(vector<vector<int>>& events, int k) {  
        ranges::sort(events, {}, [](auto &e){return e[1];});  
        int n = events.size();  
        vector f(n+1, vector(k+1, 0));  // f[i][j] 表示 前i个会议中,参加最多j个,获得的最大收益  
        for (int i = 0; i < n; ++i) { /*遍历会议*/  
            // 二分查找当前这个会议,最早可以在哪个会议结束后,开始  
            int p = lower_bound(events.begin(), events.begin() + i, events[i][0],  
                                [](auto& e, int lower) { return e[1] < lower; }) - events.begin();  
            for (int j = 1; j <= k; ++j) {  
                // 迭代计算前i场会议中,分别参加1~k场可以获得的最大收益  
                f[i+1][j] = max(f[i][j], f[p][j-1] + events[i][2]);  
            }  
        }  
        return f[n][k];  
    }  
};

Golang

go 复制代码
func maxValue(events [][]int, k int) int {
    // 按照结束时间升序排序
    sort.Slice(events, func(i, j int) bool {
        return events[i][1] < events[j][1]
    }) 
    n := len(events)
    // 初始化DP数组:f[i][j]表示前i个会议中参加最多j个会议的最大收益
    f := make([][]int, n+1)
    for i := range f {
        f[i] = make([]int, k+1)
    }

    for i := 0; i < n; i++ {
        // 二分查找:找到结束时间小于当前会议开始时间的最后一个会议
        p := sort.Search(i, func(j int) bool {
            return events[j][1] >= events[i][0]
        })
        // 状态转移
        for j := 1; j <= k; j++ {
            // 选择当前会议:f[p][j-1] + events[i][2]
            // 不选当前会议:f[i][j]
            f[i+1][j] = max(f[i][j], f[p][j-1]+events[i][2])
        }
    }
    return f[n][k]
}
相关推荐
lifallen16 分钟前
Paimon LSM Tree Compaction 策略
java·大数据·数据结构·数据库·算法·lsm-tree
web_Hsir3 小时前
vue3.2 前端动态分页算法
前端·算法
地平线开发者5 小时前
征程 6M 部署 Omnidet 感知模型
算法·自动驾驶
秋说5 小时前
【PTA数据结构 | C语言版】线性表循环右移
c语言·数据结构·算法
浩瀚星辰20246 小时前
图论基础算法:DFS、BFS、并查集与拓扑排序的Java实现
java·算法·深度优先·图论
JiaJZhong8 小时前
力扣.最长回文子串(c++)
java·c++·leetcode
oioihoii8 小时前
C++随机打乱函数:简化源码与原理深度剖析
开发语言·c++·算法
不知名。。。。。。。。8 小时前
分治算法---快排
算法
minji...9 小时前
数据结构 算法复杂度(1)
c语言·开发语言·数据结构·算法
凌肖战9 小时前
力扣网编程150题:加油站(贪心解法)
算法·leetcode·职场和发展