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

我想对大家说的话
闻缺陷则喜是一个美好的愿望,早发现问题,早修改问题,给老板节约钱。
子墨子言之:事无终始,无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙,那算法就是他的是睛
相关推荐
捕鲸叉29 分钟前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer33 分钟前
【C++】vector 类深度解析:探索动态数组的奥秘
开发语言·c++·算法
Peter_chq36 分钟前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
wheeldown1 小时前
【数据结构】选择排序
数据结构·算法·排序算法
青花瓷2 小时前
C++__XCode工程中Debug版本库向Release版本库的切换
c++·xcode
观音山保我别报错2 小时前
C语言扫雷小游戏
c语言·开发语言·算法
幺零九零零3 小时前
【C++】socket套接字编程
linux·服务器·网络·c++
TangKenny3 小时前
计算网络信号
java·算法·华为
景鹤3 小时前
【算法】递归+深搜:814.二叉树剪枝
算法
iiFrankie3 小时前
SCNU习题 总结与复习
算法