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

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

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

本题的其它解法

本文涉及的基础知识点

题目

分析

时间复杂度

变量解释

注意

代码

核心代码

测试用例

优化

代码

时间复杂度

分析

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

代码

分析

优点

注意

扩展阅读

视频课程

相关下载