英雄决斗的最大胜利次数 | 豆包MarsCode AI刷题

. 函数定义

pythonCopy Code
def solution(number, heroes):

• number 是小U的英雄数量，同时也是小F英雄的数量。
• heroes 是一个列表，包含了小F每个英雄的能力值。

2. 小U的英雄能力值初始化

pythonCopy Code
u_heroes = list(range(1, number + 1))

• 小U的英雄能力值是从 1 到 number 的一系列整数，因此 u_heroes 是一个从1到 number 的递增列表。
• 举例来说，如果 number = 7，那么 u_heroes 就是 [1, 2, 3, 4, 5, 6, 7]。

3. 小F英雄能力值排序

pythonCopy Code
heroes.sort()

• 小F的英雄能力值存储在 heroes 列表中，使用 heroes.sort() 对这个列表进行升序排序。
• 排序是为了便于后面使用贪心算法和双指针策略，使小F每次能够选择最小的能战胜小U英雄的英雄。

4. 双指针初始化

pythonCopy Code
u_idx = 0
f_idx = 0
wins = 0

• u_idx 用来指向小U英雄列表的当前英雄，初始指向小U的第一个英雄（索引为0）。
• f_idx 用来指向小F英雄列表的当前英雄，初始指向小F的第一个英雄（索引为0）。
• wins 变量记录小F的胜利次数，初始化为0。

5. 双指针遍历

pythonCopy Code
while u_idx < number and f_idx < number:
    if heroes[f_idx] > u_heroes[u_idx]:  # 小F的英雄可以赢
        wins += 1
        u_idx += 1  # 小U的英雄进入下一轮
    f_idx += 1  # 小F的英雄进入下一轮

• while u_idx < number and f_idx < number:：当小U和小F的英雄都有剩余时，继续比赛。

• if heroes[f_idx] > u_heroes[u_idx]：如果小F当前英雄的能力值大于小U当前英雄的能力值，说明小F可以击败小U的英雄。

  • wins += 1：小F胜利，增加胜利次数。
  • u_idx += 1：小U的英雄进入下一轮比赛（即小U的英雄指针右移）。

• 无论小F是否胜利，f_idx += 1：小F的英雄指针都会后移，表示小F使用了一个英雄。

6. 返回结果

pythonCopy Code
return wins

• 循环结束后，返回小F的胜利次数 wins。

7. 测试用例

pythonCopy Code
if __name__ == "__main__":
    print(solution(7, [10, 1, 1, 1, 5, 5, 3]))  # 4
    print(solution(5, [1, 1, 1, 1, 1]))  # 0
    print(solution(6, [9, 4, 7, 3, 2, 6]))  # 6

测试用例1：solution(7, [10, 1, 1, 1, 5, 5, 3])

• 小U的英雄能力值：[1, 2, 3, 4, 5, 6, 7]

• 小F的英雄能力值：[1, 1, 1, 3, 5, 5, 10]（排序后的结果）

• 比赛过程：

  1. 小F用 3 击败小U的 1。
  2. 小F用 5 击败小U的 2。
  3. 小F用另一个 5 击败小U的 4。
  4. 小F用 10 击败小U的 6。

• 小F获得了4次胜利，返回 4。

测试用例2：solution(5, [1, 1, 1, 1, 1])

• 小U的英雄能力值：[1, 2, 3, 4, 5]

• 小F的英雄能力值：[1, 1, 1, 1, 1]

• 比赛过程：

  • 小F的所有英雄能力值都比小U的英雄低，因此小F无法战胜任何小U的英雄。

• 小F没有胜利，返回 0。

测试用例3：solution(6, [9, 4, 7, 3, 2, 6])

• 小U的英雄能力值：[1, 2, 3, 4, 5, 6]

• 小F的英雄能力值：[2, 3, 4, 6, 7, 9]（排序后的结果）

• 比赛过程：

  1. 小F用 2 击败小U的 1。
  2. 小F用 3 击败小U的 2。
  3. 小F用 4 击败小U的 3。
  4. 小F用 6 击败小U的 4。
  5. 小F用 7 击败小U的 5。
  6. 小F用 9 击败小U的 6。

• 小F获得了6次胜利，返回 6。

8. 时间复杂度分析

• 排序：排序 heroes 列表的时间复杂度是 O(n log n)，其中 n 是英雄的数量。
• 双指针遍历：双指针遍历 u_heroes 和 heroes 的时间复杂度是 O(n)，每个英雄最多被访问一次。
• 总时间复杂度：O(n log n)，由于排序是最耗时的操作。

9. 空间复杂度分析

• 主要的空间开销是存储两个列表：heroes 和 u_heroes，它们的空间复杂度是 O(n)，其中 n 是英雄的数量。

总结

这段代码通过使用贪心算法和双指针策略，实现了一个高效的解决方案。小F通过尽量使用最小的英雄战胜小U的英雄，从而最大化小F的胜利次数。时间复杂度为 O(n log n)，非常适合中等规模的输入。