【C++动态规划 离散化】1626. 无矛盾的最佳球队|2027

本文涉及知识点

C++动态规划 离散化

LeetCode1626. 无矛盾的最佳球队

假设你是球队的经理。对于即将到来的锦标赛,你想组合一支总体得分最高的球队。球队的得分是球队中所有球员的分数 总和 。

然而,球队中的矛盾会限制球员的发挥,所以必须选出一支 没有矛盾 的球队。如果一名年龄较小球员的分数 严格大于 一名年龄较大的球员,则存在矛盾。同龄球员之间不会发生矛盾。

给你两个列表 scores 和 ages,其中每组 scores[i] 和 ages[i] 表示第 i 名球员的分数和年龄。请你返回 所有可能的无矛盾球队中得分最高那支的分数 。

示例 1:

输入:scores = [1,3,5,10,15], ages = [1,2,3,4,5]

输出:34

解释:你可以选中所有球员。

示例 2:

输入:scores = [4,5,6,5], ages = [2,1,2,1]

输出:16

解释:最佳的选择是后 3 名球员。注意,你可以选中多个同龄球员。

示例 3:

输入:scores = [1,2,3,5], ages = [8,9,10,1]

输出:6

解释:最佳的选择是前 3 名球员。

提示:

1 <= scores.length, ages.length <= 1000

scores.length == ages.length

1 <= scores[i] <= 10^6^

1 <= ages[i] <= 1000

动态规划+离散化

将分数离散化,并用nums记录原始分数。分数最小的位1,次小的为2 ⋯ \cdots ⋯ 。

将年龄离散化,方便处理比当前队员年龄小的队员。

动态规划的状态表示

dp[i][j] 表示 球员的年龄 <= i,离散化后的能力 <=j 组成的无矛盾球队的最大得分。空间复杂度:O(nm) m是离散后的最大年龄

动态规划的填表顺序

将任意最优解,按如下方式排序后,仍然是最优解。

一,年龄小的在前,年龄大的在后。

二,年龄相等,能力小的在前,能力大的在后。

三,年龄能力都相等,按scores中的顺序。

indexs的球员的下标按上述方式排序,按k:indexs顺序处理各球员。

动态规划的转移方程

i = ages[k] j = scores[k]
d p [ i ] [ j ] = M a x { d p [ i ] [ j ] + 当前球员的能力 前一个球员年龄相同 d p [ i − 1 ] [ j ] + 当前球员的能力 前一个球员年龄不同 dp[i][j]=Max\begin{cases} dp[i][j]+当前球员的能力 &&前一个球员年龄相同 \\ dp[i-1][j]+当前球员的能力 && 前一个球员年龄不同\\ \end{cases} dp[i][j]=Max{dp[i][j]+当前球员的能力dp[i−1][j]+当前球员的能力前一个球员年龄相同前一个球员年龄不同

每次更新dp后,都要:

cpp 复制代码
for (j =1 ; j <= N; j++) {
						dp[i][j] = max(dp[i][j], dp[i][j - 1]);
						dp[i][j] = max(dp[i][j], dp[i-1][j ]);
					}

时间复杂度:O(nm)

动态规划的初始值

全为0

动态规划的返回值

dp的最大值。

代码

核心代码

cpp 复制代码
class Solution {
		public:
			int bestTeamScore(vector<int>& scores, vector<int>& ages) {
				const int N = scores.size();
				{
					auto tmp = ages;
					tmp.emplace_back(0);
					CDiscretize dis(tmp);
					for (auto& i : ages) {
						i = dis[i];
					}
				}
				const int M = *max_element(ages.begin(), ages.end());
				auto tmp = scores;
				tmp.emplace_back(0);
				CDiscretize dis(tmp);
				for (auto& i : scores) {
					i = dis[i];
				}
				
				vector<int> index(N);
				iota(index.begin(), index.end(), 0);
				sort(index.begin(), index.end(), [&](int i1, int i2) {
					return (ages[i1] < ages[i2]) || ((ages[i1] == ages[i2]) && (scores[i1] < scores[i2]));	});
				vector<vector<int>> dp(M + 1, vector<int>(N + 1));
				int ans = 0;
				for (int k : index) {
					const int i = ages[k];
					int j = scores[k];
					dp[i][j] = max(dp[i - 1][j], dp[i][j]) + dis.m_nums[j];
					ans = max(ans, dp[i][j]);
					for (j =1 ; j <= N; j++) {
						dp[i][j] = max(dp[i][j], dp[i][j - 1]);
						dp[i][j] = max(dp[i][j], dp[i-1][j ]);
					}
				}
				return ans;
			}
		};

单元测试

cpp 复制代码
vector<int> scores, ages;
		TEST_METHOD(TestMethod1)
		{
			scores = { 3,2,4 }, ages = { 1,2,3 };
			auto res = Solution().bestTeamScore(scores, ages);
			AssertEx(7, res);
		}
		TEST_METHOD(TestMethod11)
		{
			scores = { 1,3,5,10,15 }, ages = { 1,2,3,4,5 };
			auto res = Solution().bestTeamScore(scores, ages);
			AssertEx(34, res);
		}
		TEST_METHOD(TestMethod12)
		{
			scores = { 4,5,6,5 }, ages = { 2,1,2,1 };
			auto res = Solution().bestTeamScore(scores, ages);
			AssertEx(16, res);
		}
		TEST_METHOD(TestMethod13)
		{
			scores = { 1,2,3,5 }, ages = { 8,9,10,1 };
			auto res = Solution().bestTeamScore(scores, ages);
			AssertEx(6, res);
		}
		TEST_METHOD(TestMethod14)
		{
			scores = { 1,1,1 }, ages = { 3,2,1 };
			auto res = Solution().bestTeamScore(scores, ages);
			AssertEx(3, res);
		}
		TEST_METHOD(TestMethod15)
		{
			scores = { 1,1,1 }, ages = { 1,3,5};
			auto res = Solution().bestTeamScore(scores, ages);
			AssertEx(3, res);
		}
		TEST_METHOD(TestMethod16)
		{
			scores = { 1,1,1,1,1,1,1,1,1,1 }, ages = { 811,364,124,873,790,656,581,446,885,134 };
			auto res = Solution().bestTeamScore(scores, ages);
			AssertEx(10, res);
		}
		TEST_METHOD(TestMethod17)
		{
			scores = { 6,5,1,7,6,5,5,4,10,4 }, ages = { 3,2,5,3,2,1,4,4,5,1 };
			auto res = Solution().bestTeamScore(scores, ages);
			AssertEx(43, res);
		}

优化

i1 < i2 ,k1 = index[i1] ,k2 = index[i2]。

某方案以球员k1结尾。

如果k1的能力小于等于k2,则此方案加上i2一定不会冲突。

如果 k1的能了大于k2,由于已经按本题解排序,所以k1的年龄一定小于k2:故一定冲突。

故只需枚举能力小于等于当前能力的球员。空间复杂度 :O(n)

可以用线段树。时间复杂度 :O(nlogn)

直接枚举时间复杂度:O(nn)

代码

cpp 复制代码
class CDiscretize //离散化
{
public:
	CDiscretize(vector<int> nums)
	{
		sort(nums.begin(), nums.end());
		nums.erase(std::unique(nums.begin(), nums.end()), nums.end());
		m_nums = nums;
		for (int i = 0; i < nums.size(); i++)
		{
			m_mValueToIndex[nums[i]] = i;
		}
	}
	int operator[](const int value)const
	{
		auto it = m_mValueToIndex.find(value);
		if (m_mValueToIndex.end() == it)
		{
			return -1;
		}
		return it->second;
	}
	int size()const
	{
		return m_mValueToIndex.size();
	}
	vector<int> m_nums;
protected:	
	unordered_map<int, int> m_mValueToIndex;
};

class Solution {
		public:
			int bestTeamScore(vector<int>& scores, vector<int>& ages) {
				const int N = scores.size();			
				CDiscretize dis(scores);
				for (auto& i : scores) {
					i = dis[i];
				}
				vector<int> index(N);
				iota(index.begin(), index.end(), 0);
				sort(index.begin(), index.end(), [&](int i1, int i2) {
					return (ages[i1] < ages[i2]) || ((ages[i1] == ages[i2]) && (scores[i1] < scores[i2]));	});
				 vector<int> dp(N + 1);
				int ans = 0;
				for (int k : index) {
					const int i = ages[k];
					int j = scores[k];
					const int iMax = *max_element(dp.begin() , dp.begin() + j + 1);
					dp[j] = max(dp[j], iMax + dis.m_nums[j]);
					ans = max(ans, dp[j]);
				}
				return ans;
			}
		};

扩展阅读

我想对大家说的话
工作中遇到的问题,可以按类别查阅鄙人的算法文章,请点击《算法与数据汇总》。
学习算法:按章节学习《喜缺全书算法册》,大量的题目和测试用例,打包下载。重视操作
有效学习:明确的目标 及时的反馈 拉伸区(难度合适) 专注
闻缺陷则喜(喜缺)是一个美好的愿望,早发现问题,早修改问题,给老板节约钱。
子墨子言之:事无终始,无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙,那算法就是他的是睛
失败+反思=成功 成功+反思=成功

视频课程

先学简单的课程,请移步CSDN学院,听白银讲师(也就是鄙人)的讲解。
https://edu.csdn.net/course/detail/38771

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

测试环境

操作系统:win7 开发环境: VS2019 C++17

或者 操作系统:win10 开发环境: VS2022 C++17

如无特殊说明,本算法用**C++**实现。

相关推荐
CodeJourney.1 分钟前
DeepSeek在MATLAB上的部署与应用
数据库·人工智能·算法·架构
烟雨迷10 分钟前
八大排序算法(C语言实现)
c语言·数据结构·学习·算法·排序算法
emmmmXxxy16 分钟前
leetcode刷题-动态规划08
算法·leetcode·动态规划
tt55555555555518 分钟前
每日一题——打家劫舍
c语言·数据结构·算法·leetcode
用心尝试1 小时前
23种设计模式的cpp举例
c++·设计模式
安於宿命1 小时前
【Linux】管道通信——命名管道
linux·服务器·c++·信息与通信
xing.yu.CTF2 小时前
Alice与Bob-素数分解密码学
算法·密码学
瓦力的狗腿子2 小时前
Starlink卫星动力学系统仿真建模第十讲-基于SMC和四元数的卫星姿态控制示例及Python实现
开发语言·python·算法
闻缺陷则喜何志丹2 小时前
【二分查找】P11201 [JOIG 2024] たくさんの数字 / Many Digits|普及
c++·算法·二分查找·洛谷·字符·数字·需要
shinelord明2 小时前
【再谈设计模式】访问者模式~操作对象结构的新视角
开发语言·数据结构·算法·设计模式·软件工程