1626. 无矛盾的最佳球队

Posted 2023-04-09 lxy

题目链接：1626. 无矛盾的最佳球队

方法一：子集型回溯 + 记忆化

解题思路

1. 先对\\(scores\\)和\\(ages\\)数组进行预处理得到\\(pair<int, int> a[n]\\)数组，\\(a[i].first = score[i], a[i].second = ages[i]\\)，然后进行\\(sort\\)排序；
2. 枚举计算\\([i, n - 1]\\)区间的最大分数\\(score_i\\) \\(= dfs(i)，i = 0, 1, ..., n - 1\\)。\\(ans = max(score_i)\\)。
3. \\(dfs(i)\\)：\\(curScore = a[i].first\\)，以\\(i\\)为起点，在\\([i + 1, n - 1]\\)中找所有满足条件a[i].second <= a[j].second的\\(j\\)，即找没有矛盾的的队员，\\(curScore = max(dfs(j) + a[i].first, curScore)\\)，return curScore。

代码

class Solution 
public:
    int bestTeamScore(vector<int>& scores, vector<int>& ages) 
        int n = scores.size(), ans = 0;
        pair<int, int> a[n];
        for (int i = 0; i < n; i ++ ) a[i] = scores[i], ages[i];
        sort(a, a + n);
        int cache[n]; memset(cache, -1, sizeof(cache));
        function<int(int)> dfs = [&](int i) -> int 
            int curScore = a[i].first;
            if (cache[i] != -1) return cache[i];
            for (int j = i + 1; j < n; j ++ ) 
                if (a[j].second >= a[i].second) 
                    curScore = max(curScore, dfs(j) + a[i].first);
                
            
            cache[i] = curScore;
            return curScore;
        ;
        for (int i = 0; i < n; i ++ ) 
            ans = max(ans, dfs(i));
        
        return ans;
    
;

方法二：动态规划

解题思路

改写上方思路为动态规划：

1. \\(cache\\)数组改为\\(f\\)数组；
2. 递归改为循环。递归过程中是在起点的右边找不矛盾的队友，然后在向右递归；循环则是对应归的过程，即 \\(i = n - 1 => 0\\)，\\(f[i] = a[i].first\\)，然后在\\(i\\)的右边\\([i + 1, n - 1]\\)中找不矛盾的\\(j\\)，\\(f[i] = max(f[i], f[j] + a[i].first)\\)；
3. \\(ans = max(f)\\)。

代码

class Solution 
public:
    int bestTeamScore(vector<int>& scores, vector<int>& ages) 
        int n = scores.size(), ans = 0;
        pair<int, int> a[n];
        for (int i = 0; i < n; i ++ ) a[i] = scores[i], ages[i];
        sort(a, a + n);
        int f[n]; memset(f, 0, sizeof(f));
        for (int i = n - 1; i >= 0; i -- ) 
            f[i] = a[i].first;
            for (int j = i; j < n; j ++ ) 
                if (a[j].second >= a[i].second) 
                    f[i] = max(f[i], f[j] + a[i].first);
                
            
            ans = max(ans, f[i]);    
        
        return ans;
    
;

复杂度分析

时间复杂度：\\(O(n^2)\\)；
空间复杂度：\\(O(n)\\)。

选择足球队球员的组合优化

【中文标题】选择足球队球员的组合优化

【英文标题】：Combinatorial optimization for selecting the players of a football team

【发布时间】：2020-12-27 07:42:20

【问题描述】：

我正在考虑使用整数规划来生成足球运动员的最佳组合以组成一个团队。

虽然问题本身很简单，但我无法为职位资格制定有效的约束条件。

我在 *** 中搜索了经典整数规划问题的变体，并提出了一个临时解决方案，但想验证当前解决方案是否有效。

问题 从一组有限的潜在球员中选择 11 名球员加入足球（足球）队。 球队由11个位置组成：5个进攻、5个防守和1个守门员。 每个角色都有自己的合格玩家池。 （例如，守门员只能从一组有手套的球员中选择） 每个玩家都被分配了一个代表他们技能的“技能分数”

目标函数 最大化：所有 11 名玩家技能分数的总和

约束

所有 11 个插槽必须至少有 1 名玩家填满 1 名玩家只能占用 1 个位置 每个位置都必须由有资格担任该角色的玩家填补

我的临时解决方案

Let xij: player i in consideration for slot j (j=1, 2,..., 11, 1 <= i <= n)
and w: n x 1 weight matrix representing skill score for player i

1. sum_j(xij) == 1 for each slot j
2. 0 <= sum_i(xij) <= 1 for each player i
3. 0 <= xij <= 1 if player i is eligible for slot j, == 0 otherwise

maximize sum(wTx)

我还没有想到一种优雅的方式来操作 3，所以我现在的答案是将每个单元格硬编码为 0。

我打算在 Python 中使用整数编程库（cvxpy 或 PuLP）。

当前的设计会导致收敛或计算时间方面的任何问题吗？

是否有更有效的方法来建模问题？

备注

为简单起见，我们假设玩家可以同时担任多个角色，但他们的技能点不会因角色而异 如果玩家的技能分数根据他们与其他玩家的协同作用而改变，问题的表述会改变吗？我认为通过 nC2 可能的交互来简单地扩展 x 矩阵是可行的，但我很好奇是否有更好的解决方案。

【参考方案1】：

您的 IP 表述看起来不错。但是，这个问题也可以使用动态规划来解决：

让数组dp[n][mask] 表示将玩家从 1 到 n 放置到mask 二进制表示中的 0 位对应的位置时可以获得的最大可能分数。例如dp[5][0b11111110101] 等于将玩家 1 到 5 放置到位置 2 和 4 所获得的最高分数。（掩码的第二和第四位为零。）

现在我们递归定义dp[n][mask]：

dp[n][mask] = max
    dp[n-1][mask], # the case when we don't use player n
    max_j dp[n-1][mask|(1<<j)] + w[n]  (1 <= j <= 11 and mask's jth bit is 0)

基本情况是n=0。

dp[0][mask] = 
    -infinity, if there are 0 bits in mask # there are empty positions left, we want to strictly discourage this case.
    0, if all 11 bits of mask is 1