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

本周推荐阅读

C++二分算法：得到子序列的最少操作次数

本题的其它解法

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中的顺序
vEndTimeIndexToMaxValuevEndTimeIndexToMaxValue[i]=j 表示，mEndTimeToIndexs[i]结束的会议的最大价值

注意

std::prev(it)之前不需要判断，因为vEndTime中插入了一个比任何开始时间都小的数0。
每轮循环后，要确保vEndTimeIndexToMaxValue升序。

代码

核心代码

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();
	}
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

测试用例

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 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);

  • 1

}

优化

代码

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());
	}
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

时间复杂度

O(nk)

分析

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

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

  • 1

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

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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

return *std::max_element(vEndTimeIndexToMaxValue.begin(), vEndTimeIndexToMaxValue.end());

  • 1

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

代码

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());
	}
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

分析

时间复杂度O(kn)。

优点

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

注意

一，开始时间降序排序。

 {return v0[0] > v1[0]; });

  • 1

二，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

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛
群中有博文配套源码
QQ群名片
注：本文转载自blog.csdn.net的闻缺陷则喜何志丹的文章"https://blog.csdn.net/he_zhidan/article/details/134583512"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！