保龄球游戏的获胜者----2023/4/30

给你两个下标从 0 开始的整数数组 player1 和 player2 ，分别表示玩家 1 和玩家 2 击中的瓶数。
保龄球比赛由 n 轮组成，每轮的瓶数恰好为 10 。
假设玩家在第 i 轮中击中 xi 个瓶子。玩家第 i 轮的价值为：
如果玩家在前两轮中击中了 10 个瓶子，则为 2xi 。
否则，为 xi 。
玩家的得分是其 n 轮价值的总和。

返回
如果玩家 1 的得分高于玩家 2 的得分，则为 1 ；
如果玩家 2 的得分高于玩家 1 的得分，则为 2 ；
如果平局，则为 0 。
示例1：

 输入：player1 = [4,10,7,9], player2 = [6,5,2,3]
输出：1
解释：player1 的得分是 4 + 10 + 2*7 + 2*9 = 46 。
player2 的得分是 6 + 5 + 2 + 3 = 16 。
player1 的得分高于 player2 的得分，所以 play1 在比赛中获胜，答案为 1 。

示例2：

输入：player1 = [3,5,7,6], player2 = [8,10,10,2]
输出：2
解释：player1 的得分是 3 + 5 + 7 + 6 = 21 。
player2 的得分是 8 + 10 + 2*10 + 2*2 = 42 。
player2 的得分高于 player1 的得分，所以 play2 在比赛中获胜，答案为 2 。

示例3：

输入：player1 = [2,3], player2 = [4,1]
输出：0
解释：player1 的得分是 2 + 3 = 5 。
player2 的得分是 4 + 1 = 5 。
player1 的得分等于 player2 的得分，所以这一场比赛平局，答案为 0 。

提示：
n == player1.length == player2.length
1 <= n <= 1000
0 <= player1[i], player2[i] <= 10
题解：

class Solution:
    def isWinner(self, player1: List[int], player2: List[int]) -> int:
        player_1, player_2 = player1[0], player2[0]
        if len(player1) > 1:
            if player_1 == 10:
                player_1 += player1[1] * 2
            else:
                player_1 += player1[1]
            if player_2 == 10:
                player_2 += player2[1] * 2
            else:
                player_2 += player2[1]

        if len(player1) > 2:
            for i in range(2, len(player1)):
                if player1[i-1] == 10 or player1[i-2] == 10:
                    player_1 += 2 * player1[i]
                else:
                    player_1 += player1[i]
                if player2[i-1] == 10 or player2[i-2] == 10:
                    player_2 += 2 * player2[i]
                else:
                    player_2 += player2[i]

        if player_1 == player_2:
            return 0
        elif player_1 > player_2:
            return 1
        else:
            return 2

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/determine-the-winner-of-a-bowling-game
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

找出叠涂元素----2023/4/30

给你一个下标从 0 开始的整数数组 arr 和一个 m x n 的整数矩阵 mat 。arr 和 mat 都包含范围 [1，m * n] 内的所有整数。
从下标 0 开始遍历 arr 中的每个下标 i ，并将包含整数 arr[i] 的 mat 单元格涂色。
请你找出 arr 中在 mat 的某一行或某一列上都被涂色且下标最小的元素，并返回其下标 i 。
在这里插入图片描述

提示：
m == mat.length
n = mat[i].length
arr.length == m * n
1 <= m, n <= 105
1 <= m * n <= 105
1 <= arr[i], mat[r][c] <= m * n
arr 中的所有整数互不相同
mat 中的所有整数互不相同

题解1：超出时间限制了

class Solution:
    def firstCompleteIndex(self, arr: List[int], mat: List[List[int]]) -> int:
        for index, arr_sub in enumerate(arr):
            for i in range(len(mat)):
                for j in range(len(mat[0])):
                    if arr_sub == mat[i][j]:
                        mat[i][j] = 0
                        flag = False
                        x = 0
                        for z in mat[i]:
                            if z != 0:
                                break
                            x += 1
                        if x == len(mat[0]):
                            flag = True

                        y = 0
                        for m in range(len(mat)):
                            if mat[m][j] != 0:
                                break
                            y += 1
                        if y == len(mat):
                            flag = True

                        if flag:
                            return index

题解2：参考

class Solution:
    def firstCompleteIndex(self, arr: List[int], mat: List[List[int]]) -> int:
        m, n = len(mat), len(mat[0])
        row, col = [0]*m, [0]*n
        has = {}
        for i in range(m):
            for j in range(n):
                has[mat[i][j]] = (i, j)
        
        for index, num in enumerate(arr):
            i, j = has[num]
            row[i] += 1
            col[j] += 1
            if row[i] == n or col[j] == m:
                return index