当前位置：首页 > article >正文

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

article 2025/1/31 7:57:28

本文涉及知识点

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⁶
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]
$dp[i][j]=Max\begin{cases} dp[i][j]+当前球员的能力 &&前一个球员年龄相同 \\ dp[i-1][j]+当前球员的能力 && 前一个球员年龄不同\\ \end{cases}$
每次更新dp后，都要：

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的最大值。

代码

核心代码

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

单元测试

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)

代码

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

扩展阅读

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