C++二分向量算法:最多可以参加的会议数目 II

本题的其它解法

C++二分算法:最多可以参加的会议数目 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

分析

时间复杂度

时间复杂度O(nlogn+knlogn)。第一步时间复杂度O(nlogn),第二步时间复杂度O(klongn)。

第一步:收集结束时间,排序并除去重复。并给每个结束时间安排索引。

第二步:两轮循环。

变量解释

vEndTime 结束时间升序并除去重复元素
mEndTimeToIndexs 结束时间在vEndTime中的顺序
vEndTimeIndexToMaxValue vEndTimeIndexToMaxValue[i]=j 表示,mEndTimeToIndexs[i]结束的会议的最大价值

注意

std::prev(it)之前不需要判断,因为vEndTime中插入了一个比任何开始时间都小的数0。

每轮循环后,要确保vEndTimeIndexToMaxValue升序。

代码

核心代码

cpp 复制代码
class Solution {
public:
	int maxValue(vector<vector<int>>& events, int k) {
		vector<int> vEndTime = { 0 };
		for (const auto& v : events)
		{
			vEndTime.emplace_back(v[1]);
		}
		sort(vEndTime.begin(), vEndTime.end());
		vEndTime.erase(std::unique(vEndTime.begin(), vEndTime.end()), vEndTime.end());
		unordered_map<int, int> mEndTimeToIndexs;
		for (int i = 0; i < vEndTime.size(); i++)
		{
			mEndTimeToIndexs[vEndTime[i]] = i;
		}
		vector<int> vEndTimeIndexToMaxValue(vEndTime.size());
		while (k--)
		{
			vector<int> dp(vEndTime.size());
			for (const auto& v : events)
			{
				int iEndIndex = mEndTimeToIndexs[v[1]];
				auto it = std::lower_bound(vEndTime.begin(), vEndTime.end(), v[0]);
				const int iMaxPreIndex = it - 1 - vEndTime.begin() ;
				const int iMaxValue = vEndTimeIndexToMaxValue[iMaxPreIndex] + v[2];
				dp[iEndIndex] = max(dp[iEndIndex],iMaxValue);
			}
			//使得dp升序
			int iPreMax = 0;
			for (auto& n : dp)
			{
				n = max(n, iPreMax);
				iPreMax = max(n, iPreMax);
			}
			dp.swap(vEndTimeIndexToMaxValue);
		}
		return vEndTimeIndexToMaxValue.back();
	}
};

测试用例

template

void Assert(const T& t1, const T& t2)

{

assert(t1 == t2);

}

template

void Assert(const vector& v1, const vector& v2)

{

if (v1.size() != v2.size())

{

assert(false);

return;

}

for (int i = 0; i < v1.size(); i++)

{

Assert(v1[i], v2[i]);

}

}

int main()

{

vector<vector> events;

int k;

int res;

{

Solution slu;

events = { {1,2,4},{3,4,3},{2,3,1} };

k = 2;

res = slu.maxValue(events, k);

Assert(res,7 );

}

{

Solution slu;

events = { {1,2,4},{3,4,3},{2,3,10} };

k = 2;

res = slu.maxValue(events, k);

Assert(res, 10);

}

{

Solution slu;

events = { {1,1,1},{2,2,2},{3,3,3},{4,4,4} };

k = 3;

res = slu.maxValue(events, k);

Assert(res, 9);

}

//CConsole::Out(res);

}

优化

代码

cpp 复制代码
class Solution {
public:
	int maxValue(vector<vector<int>>& events, int k) {
		vector<int> vEndTime = { 0 };
		for (const auto& v : events)
		{
			vEndTime.emplace_back(v[1]);
		}
		sort(vEndTime.begin(), vEndTime.end());
		vEndTime.erase(std::unique(vEndTime.begin(), vEndTime.end()), vEndTime.end());
		unordered_map<int, int> mEndTimeToIndexs;
		for (int i = 0; i < vEndTime.size(); i++)
		{
			mEndTimeToIndexs[vEndTime[i]] = i;
		}
		sort(events.begin(), events.end(), [](const auto& v0, const auto& v1) {return v0[0] < v1[0]; });
		vector<int> vEndTimeIndexToMaxValue(vEndTime.size());
		while (k--)
		{
			vector<int> dp(vEndTime.size());
			int iPreMax = 0;
			int iPreIndex = 0;
			for (const auto& v : events)
			{
				while ((iPreIndex < vEndTimeIndexToMaxValue.size()) && (vEndTime[iPreIndex] < v[0]))
				{
					iPreMax = max(iPreMax, vEndTimeIndexToMaxValue[iPreIndex]);
					iPreIndex++;
				}
				int iEndIndex = mEndTimeToIndexs[v[1]];
				dp[iEndIndex] = max(dp[iEndIndex], iPreMax+v[2]);
			}
			dp.swap(vEndTimeIndexToMaxValue);			
		}
		return *std::max_element(vEndTimeIndexToMaxValue.begin(), vEndTimeIndexToMaxValue.end());
	}
};

时间复杂度

O(nk)

分析

将events通过开始时间排序后,就可以使用离线查询。

cpp 复制代码
sort(events.begin(), events.end(), [](const auto& v0, const auto& v1) {return v0[0] < v1[0]; });

iPreMax 记录了所有结束时间比当前时间小的最大会议价值的最大值。

cpp 复制代码
vEndTimeIndexToMaxValue[0,iPreIndex)的会议价值已经更新到iPreMax。 
while ((iPreIndex < vEndTimeIndexToMaxValue.size()) && (vEndTime[iPreIndex] < v[0]))
				{
					iPreMax = max(iPreMax, vEndTimeIndexToMaxValue[iPreIndex]);
					iPreIndex++;
				}

注意: vEndTimeIndexToMaxValue不再升序,所以要:

cpp 复制代码
return *std::max_element(vEndTimeIndexToMaxValue.begin(), vEndTimeIndexToMaxValue.end());

优化二:从开始时间大的处理

代码

cpp 复制代码
class Solution {
public:
	int maxValue(vector<vector<int>>& events, int k) {
		vector<int> vEndTime = { 0 };
		for (const auto& v : events)
		{
			vEndTime.emplace_back(v[1]);
		}
		sort(vEndTime.begin(), vEndTime.end());
		vEndTime.erase(std::unique(vEndTime.begin(), vEndTime.end()), vEndTime.end());
		unordered_map<int, int> mEndTimeToIndexs;
		for (int i = 0; i < vEndTime.size(); i++)
		{
			mEndTimeToIndexs[vEndTime[i]] = i;
		}
		sort(events.begin(), events.end(), [](const auto& v0, const auto& v1) {return v0[0] > v1[0]; });
		vector<int> vEndTimeIndexToMaxValue(vEndTime.size());
		while (k--)
		{
			int iPreIndex = vEndTimeIndexToMaxValue.size()-1 ;
			for (const auto& v : events)
			{
				while ((iPreIndex >=0 ) && (vEndTime[iPreIndex] >= v[0]))
				{	
					iPreIndex--;
				}
				int iEndIndex = mEndTimeToIndexs[v[1]];
				vEndTimeIndexToMaxValue[iEndIndex] = max(vEndTimeIndexToMaxValue[iEndIndex], vEndTimeIndexToMaxValue[iPreIndex] +v[2]);
			}
			//使得dp升序
			int iPreMax = 0;
			for (auto& n : vEndTimeIndexToMaxValue)
			{
				n = max(n, iPreMax);
				iPreMax = max(n, iPreMax);
			}
		}
		return *std::max_element(vEndTimeIndexToMaxValue.begin(), vEndTimeIndexToMaxValue.end());
	}
};

分析

时间复杂度O(kn)。

优点

不需要滚动向量,因为更新结束时间大的不会影响开始时间小的。

注意

一,开始时间降序排序。

cpp 复制代码
 {return v0[0] > v1[0]; });

二,vEndTimeIndexToMaxValue必须保持升序。

扩展阅读

视频课程

有效学习:明确的目标 及时的反馈 拉伸区(难度合适),可以先学简单的课程,请移步CSDN学院,听白银讲师(也就是鄙人)的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快

速形成战斗了,为老板分忧,请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关下载

想高屋建瓴的学习算法,请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
闻缺陷则喜是一个美好的愿望,早发现问题,早修改问题,给老板节约钱。
子墨子言之:事无终始,无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙,那算法就是他的是睛
相关推荐
不去幼儿园9 分钟前
【MARL】深入理解多智能体近端策略优化(MAPPO)算法与调参
人工智能·python·算法·机器学习·强化学习
Mr_Xuhhh11 分钟前
重生之我在学环境变量
linux·运维·服务器·前端·chrome·算法
Ajiang28247353041 小时前
对于C++中stack和queue的认识以及priority_queue的模拟实现
开发语言·c++
盼海1 小时前
排序算法(五)--归并排序
数据结构·算法·排序算法
网易独家音乐人Mike Zhou5 小时前
【卡尔曼滤波】数据预测Prediction观测器的理论推导及应用 C语言、Python实现(Kalman Filter)
c语言·python·单片机·物联网·算法·嵌入式·iot
‘’林花谢了春红‘’6 小时前
C++ list (链表)容器
c++·链表·list
机器视觉知识推荐、就业指导7 小时前
C++设计模式:建造者模式(Builder) 房屋建造案例
c++
Swift社区8 小时前
LeetCode - #139 单词拆分
算法·leetcode·职场和发展
Kent_J_Truman9 小时前
greater<>() 、less<>()及运算符 < 重载在排序和堆中的使用
算法