游戏队友搜索

这道题的目标是从比赛历史记录中找到指定玩家的符合条件的队友。通过逻辑分析，题目的主要任务是实现以下步骤：

---

解决思路

1. 构建玩家与游戏的关系映射：

   • 利用给定的比赛记录 array，找出指定玩家 id 参与过的所有比赛局次。
   • 统计其他玩家与指定玩家参与过的共同比赛次数。

2. 队友定义：

   • 如果某玩家与指定玩家参与过的共同比赛次数达到至少两次，则将该玩家的 ID 作为队友。

3. 遍历与统计：

   • 先提取指定玩家参与的比赛局次。
   • 遍历其他玩家的比赛记录，统计共同比赛的次数。

4. 输出排序：

   • 将符合条件的玩家 ID 按升序输出。

---

算法设计

1. 数据结构：

   • 使用字典记录每个玩家参与的比赛局次。
   • 利用集合交集计算共同参与的比赛局次。

2. 主要步骤：

   • 构建比赛数据的字典：player_games，键为玩家 ID，值为该玩家参与过的比赛局次集合。
   • 获取指定玩家 id 的比赛局次集合。
   • 遍历其他玩家，计算每个玩家与指定玩家的共同比赛次数。

3. 复杂度分析：

   • 构建字典的复杂度为 O(n)O(n)，其中 nn 是比赛记录的长度。
   • 计算交集的复杂度与玩家数目以及比赛局次相关。
   • 整体复杂度为 O(n⋅m)O(n \cdot m)，其中 mm 是平均每位玩家参与的比赛数。

---

代码实现

以下是 Python 实现：

def solution(id, num, array):
    from collections import defaultdict

    # 构建玩家 -> 比赛局次的映射
    player_games = defaultdict(set)
    for player_id, game_id in array:
        player_games[player_id].add(game_id)

    # 获取指定玩家参与的比赛局次
    target_games = player_games[id]
    teammates = []

    # 遍历所有玩家，统计共同比赛次数
    for player_id, games in player_games.items():
        if player_id != id:  # 不考虑自己
            # 计算共同比赛的次数
            common_games = target_games & games
            if len(common_games) >= 2:  # 至少一起参与 2 局
                teammates.append(player_id)

    # 返回升序的队友列表
    return sorted(teammates)


# 测试用例
if __name__ == "__main__":
    print(
        solution(
            1,
            10,
            [
                [1, 1],
                [1, 2],
                [1, 3],
                [2, 1],
                [2, 4],
                [3, 2],
                [4, 1],
                [4, 2],
                [5, 2],
                [5, 3],
            ],
        )
        == [4, 5]
    )
    print(
        solution(
            2,
            6,
            [
                [2, 1],
                [2, 3],
                [1, 1],
                [1, 2],
                [3, 1],
                [4, 3],
            ],
        )
        == []
    )
    print(
        solution(
            3,
            8,
            [
                [3, 1],
                [3, 2],
                [3, 3],
                [4, 1],
                [5, 2],
                [6, 3],
                [7, 1],
                [7, 2],
            ],
        )
        == [7]
    )

---

代码详解

1. 构建字典 player_games：

   • 遍历 array，将每个玩家的比赛局次存储为集合，这样可以快速计算交集。

2. 获取指定玩家的比赛局次：

   • 通过 player_games[id] 获取指定玩家的比赛记录集合。

3. 遍历其他玩家：

   • 计算与指定玩家的共同比赛局次 common_games（利用集合交集 &）。
   • 如果共同比赛的数量达到至少两次，将该玩家 ID 添加到结果中。

4. 排序输出：

   • 返回符合条件的玩家 ID 的升序排列。

---

测试结果分析

测试用例 1：

输入：

id = 1
num = 10
array = [    [1, 1], [1, 2], [1, 3],
    [2, 1], [2, 4],
    [3, 2],
    [4, 1], [4, 2],
    [5, 2], [5, 3]
]

• 玩家 1 的比赛局次：{1, 2, 3}
• 玩家 4 的共同比赛：{1, 2}（两局，符合条件）
• 玩家 5 的共同比赛：{2, 3}（两局，符合条件） 输出：[4, 5]

测试用例 2：

输入：

id = 2
num = 6
array = [    [2, 1], [2, 3],
    [1, 1], [1, 2],
    [3, 1],
    [4, 3]
]

• 玩家 2 的比赛局次：{1, 3}
• 所有其他玩家均不满足至少两局共同比赛。 输出：[]

测试用例 3：

输入：

id = 3
num = 8
array = [    [3, 1], [3, 2], [3, 3],
    [4, 1],
    [5, 2],
    [6, 3],
    [7, 1], [7, 2]
]

• 玩家 3 的比赛局次：{1, 2, 3}
• 玩家 7 的共同比赛：{1, 2}（两局，符合条件） 输出：[7]

---

总结

本解决方案通过构建玩家与比赛局次的映射，并利用集合的交集高效统计共同比赛次数，满足题目的功能需求。算法清晰易懂，能够适应更大规模的输入数据。