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

扩展阅读

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