每日一题， 找到连续赢 K 场比赛的第一位玩家

有 n 位玩家在进行比赛，玩家编号依次为 0 到 n - 1 。

给你一个长度为 n 的整数数组 skills 和一个 正 整数 k ，其中 skills[i] 是第 i 位玩家的技能等级。skills 中所有整数 互不相同 。

所有玩家从编号 0 到 n - 1 排成一列。

比赛进行方式如下：

• 队列中最前面两名玩家进行一场比赛，技能等级 更高 的玩家胜出。
• 比赛后，获胜者保持在队列的开头，而失败者排到队列的末尾。

这个比赛的赢家是 第一位连续 赢下 k 场比赛的玩家。

请你返回这个比赛的赢家编号。

示例 1：

输入：skills = [4,2,6,3,9], k = 2

输出：2

解释：

一开始，队列里的玩家为 [0,1,2,3,4] 。比赛过程如下：

• 玩家 0 和 1 进行一场比赛，玩家 0 的技能等级高于玩家 1 ，玩家 0 胜出，队列变为 [0,2,3,4,1] 。
• 玩家 0 和 2 进行一场比赛，玩家 2 的技能等级高于玩家 0 ，玩家 2 胜出，队列变为 [2,3,4,1,0] 。
• 玩家 2 和 3 进行一场比赛，玩家 2 的技能等级高于玩家 3 ，玩家 2 胜出，队列变为 [2,4,1,0,3] 。

玩家 2 连续赢了 k = 2 场比赛，所以赢家是玩家 2 。

示例 2：

输入：skills = [2,5,4], k = 3

输出：1

解释：

一开始，队列里的玩家为 [0,1,2] 。比赛过程如下：

• 玩家 0 和 1 进行一场比赛，玩家 1 的技能等级高于玩家 0 ，玩家 1 胜出，队列变为 [1,2,0] 。
• 玩家 1 和 2 进行一场比赛，玩家 1 的技能等级高于玩家 2 ，玩家 1 胜出，队列变为 [1,0,2] 。
• 玩家 1 和 0 进行一场比赛，玩家 1 的技能等级高于玩家 0 ，玩家 1 胜出，队列变为 [1,2,0] 。

玩家 1 连续赢了 k = 3 场比赛，所以赢家是玩家 1 。

提示：

• n == skills.length
• 2 <= n <= 105
• 1 <= k <= 109
• 1 <= skills[i] <= 106
• skills 中的整数互不相同。

考查内容

1. 队列操作：如何高效地管理和操作队列，特别是在进行多次比赛的过程中。
2. 贪心算法：如何在每一步选择最优解，以确保最终结果的正确性。
3. 循环和条件判断：如何在循环中正确地进行条件判断，以确定某位玩家是否已经连续赢了 k 场比赛。
4. 数据结构的选择：如何选择合适的数据结构来存储和操作玩家的技能等级和队列顺序。

代码实现

function findWinningPlayer(skills, k) {
    const n = skills.length; // 玩家数量
    let cnt = 0; // 当前玩家的连胜次数
    let i = 0, last_i = 0; // 当前玩家的索引和上一个获胜者的索引

    while (i < n) {
        let j = i + 1; // 下一个对手的索引
        // 内层循环：比较当前玩家和后续玩家的技能等级
        while (j < n && skills[j] < skills[i] && cnt < k) {
            j++; // 移动到下一个对手
            cnt++; // 当前玩家连胜次数增加
        }
        // 如果当前玩家连胜次数达到 k，返回当前玩家的索引
        if (cnt === k) {
            return i;
        }
        // 重置连胜次数为 1，因为当前玩家至少赢了一次
        cnt = 1;
        last_i = i; // 更新上一个获胜者的索引
        i = j; // 更新当前玩家的索引为下一个对手的索引
    }
    // 如果遍历完所有玩家都没有找到连胜 k 场的玩家，返回上一个获胜者的索引
    return last_i;
}

// 示例测试
const skills1 = [4, 2, 6, 3, 9];
const k1 = 2;
console.log(findWinningPlayer(skills1, k1));  // 输出: 2

const skills2 = [2, 5, 4];
const k2 = 3;
console.log(findWinningPlayer(skills2, k2));  // 输出: 1

详细注释

1. 初始化变量：

   • n：玩家数量。
   • cnt：当前玩家的连胜次数，初始值为 0。
   • i：当前玩家的索引，初始值为 0。
   • last_i：上一个获胜者的索引，初始值为 0。

2. 外层循环：

   • while (i < n)：遍历每个玩家，从 i 开始。
   • let j = i + 1：初始化 j 为 i + 1，表示下一个对手。

3. 内层循环：

   • while (j < n && skills[j] < skills[i] && cnt < k)：比较玩家 i 和玩家 j 的技能等级。
     • j < n：确保 j 不超过玩家总数。
     • skills[j] < skills[i]：如果玩家 i 的技能等级高于玩家 j，则玩家 i 获胜。
     • cnt < k：确保当前玩家的连胜次数还没有达到 k。
   • j++：移动到下一个对手。
   • cnt++：当前玩家连胜次数增加。

4. 检查连胜次数：

   • if (cnt === k)：如果玩家 i 的连胜次数达到 k，返回玩家 i 的索引。

5. 更新变量：

   • cnt = 1：重置连胜次数为 1，因为当前玩家至少赢了一次。
   • last_i = i：更新上一个获胜者的索引。
   • i = j：更新当前玩家的索引为下一个对手的索引。

6. 返回结果：

   • return last_i：如果遍历完所有玩家都没有找到连胜 k 场的玩家，返回上一个获胜者的索引。

复杂度分析

时间复杂度：O(n)，其中 n 是 skills 的长度。由于每个元素最多遍历一次，因此总体的时间复杂度为 O(n)。

空间复杂度：O(1)，只使用了若干个变量。

时间复杂度，空间复杂度 概念解释

O(n) 是大 O 表示法（Big O notation），用于描述算法的时间复杂度或空间复杂度。具体来说，O(n) 表示算法的运行时间或空间使用量随着输入规模 n 的增长呈线性关系。

时间复杂度 O(n) 的含义

1. 线性增长：

   • 如果一个算法的时间复杂度是 O(n)，这意味着算法的运行时间随着输入规模 n 的增加而线性增长。
   • 例如，如果输入规模 n 增加一倍，算法的运行时间也会大致增加一倍。

2. 常见场景：

   • 单次遍历：最常见的 O(n) 时间复杂度出现在需要遍历整个数组或列表的情况。例如，计算数组中所有元素的和、查找数组中的最大值或最小值等。
   • 简单循环：只有一个简单的循环，循环次数与输入规模 n 成正比。

示例

假设我们有一个数组 arr，长度为 n，我们需要计算数组中所有元素的和：

function sumArray(arr) {
    let sum = 0;
    for (let i = 0; i < arr.length; i++) {
        sum += arr[i];
    }
    return sum;
}

在这个例子中，循环会遍历数组中的每一个元素，因此时间复杂度是 O(n)。

为什么这个算法的时间复杂度是 O(n)?

在您提供的算法中，时间复杂度是 O(n) 的原因如下：

1. 外层循环：

   • while (i < n)：遍历每个玩家，从 i 开始。这个循环会遍历每个玩家一次。

2. 内层循环：

   • while (j < n && skills[j] < skills[i] && cnt < k)：比较玩家 i 和后续玩家的技能等级。虽然这是一个嵌套循环，但每个玩家最多只会被比较一次，因为一旦 j 超过 n 或者 cnt 达到 k，内层循环就会结束。

3. 总体时间复杂度：

   • 由于每个玩家最多只会被比较一次，因此总体的时间复杂度为 O(n)。

空间复杂度 O(1) 的含义

1. 常数空间：
   • 如果一个算法的空间复杂度是 O(1)，这意味着算法使用的额外空间是固定的，不随输入规模 n 的变化而变化。
   • 例如，算法中只使用了固定数量的变量，没有使用额外的数据结构（如数组、对象等）。

 示例代码及其注释

function findWinningPlayer(skills, k) {
    const n = skills.length; // 玩家数量
    let cnt = 0; // 当前玩家的连胜次数
    let i = 0, last_i = 0; // 当前玩家的索引和上一个获胜者的索引

    while (i < n) {
        let j = i + 1; // 下一个对手的索引
        // 内层循环：比较当前玩家和后续玩家的技能等级
        while (j < n && skills[j] < skills[i] && cnt < k) {
            j++; // 移动到下一个对手
            cnt++; // 当前玩家连胜次数增加
        }
        // 如果当前玩家连胜次数达到 k，返回当前玩家的索引
        if (cnt === k) {
            return i;
        }
        // 重置连胜次数为 1，因为当前玩家至少赢了一次
        cnt = 1;
        last_i = i; // 更新上一个获胜者的索引
        i = j; // 更新当前玩家的索引为下一个对手的索引
    }
    // 如果遍历完所有玩家都没有找到连胜 k 场的玩家，返回上一个获胜者的索引
    return last_i;
}

总结

• 时间复杂度 O(n)：每个玩家最多只会被比较一次，因此总体的时间复杂度为 O(n)。
• 空间复杂度 O(1)：算法只使用了固定数量的变量，没有使用额外的数据结构，因此空间复杂度为 O(1)。