2660：保龄球游戏的获胜者

题目描述

描述：给你两个下标从 0 开始的整数数组 player1 和 player2 ，分别表示玩家 1 和玩家 2 击中的瓶数。

保龄球比赛由 n 轮组成，每轮的瓶数恰好为 10 。

假设玩家在第 i 轮中击中 xi 个瓶子。玩家第 i 轮的价值为：

如果玩家在前两轮中击中了 10 个瓶子，则为 2xi 。
否则，为 xi 。
玩家的得分是其 n 轮价值的总和。

返回

如果玩家 1 的得分高于玩家 2 的得分，则为 1 ；
如果玩家 2 的得分高于玩家 1 的得分，则为 2 ；
如果平局，则为 0 。

输入：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 。

输入：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 。

输入：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

解题思路

思路：最直观的想法是，遍历数组player1和player2，假设某一玩家当前轮瓶数为x，如果某一玩家当前轮数的前两轮中的某一轮瓶数为10瓶，则该玩家当前轮分数为2x，反之为x。其中需要对第一轮和第二轮特殊处理。

int isWinner(vector<int>& player1, vector<int>& player2) {
        int n=player1.size(); //player1=player2
        int num1=player1[0],num2=player2[0]; //n>=1
        if(n>1)  //长度大于1 前两轮也包括前一轮 特殊考虑第2个位置
        {
            if(player1[0]==10)
                num1+=2*player1[1];
            else
                num1+=player1[1];
            if(player2[0]==10)
                num2+=2*player2[1];
            else
                num2+=player2[1];
        }
        for(int i=2;i<n;i++) //一起遍历
        {
            if(player1[i-1]==10||player1[i-2]==10)
                num1+=2*player1[i];
            else
                num1+=player1[i];
            if(player2[i-1]==10||player2[i-2]==10)
                num2+=2*player2[i];
            else
                num2+=player2[i];
        }
        int res;
        if(num1>num2) //比较结果
            res=1;
        else if(num1<num2)
            res=2;
        else 
            res=0;
        return res;
    }

2661：找出叠涂元素

题目描述

描述：给你一个下标从 0 开始的整数数组 arr 和一个 m x n 的整数 矩阵 mat 。arr 和 mat 都包含范围 [1，m * n] 内的 所有 整数。

从下标 0 开始遍历 arr 中的每个下标 i ，并将包含整数 arr[i] 的 mat 单元格涂色。

请你找出 arr 中在 mat 的某一行或某一列上都被涂色且下标最小的元素，并返回其下标 i 。

示例 1：

输入：arr = [1,3,4,2], mat = [[1,4],[2,3]]
输出：2
解释：遍历如上图所示，arr[2] 在矩阵中的第一行或第二列上都被涂色。

示例 2：

输入：arr = [2,8,7,4,1,3,5,6,9], mat = [[3,2,5],[1,4,6],[8,7,9]]
输出：3
解释：遍历如上图所示，arr[3] 在矩阵中的第二列上都被涂色。

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 中的所有整数 互不相同

解题思路

思路：最直观的想法是，两重循环遍历mat，然后将其按照<值，<行下标，列下标>>的形式存储在umap中，使用row记录每行已经填充的列数，使用col记录每列已经填充的行数，然后遍历arr，将其对应元素的行和列进行加一，如果某一行或者某一列已满，则标记arr下标并退出循环且返回下标。

int firstCompleteIndex(vector<int>& arr, vector<vector<int>>& mat) 
{
   int m=mat.size();
   int n=mat[0].size();
   unordered_map<int,vector<int>> umap;
   for(int i=0;i<m;i++)  //初始化 值 [行下标，列下标]
   {
      for(int j=0;j<n;j++)
      {
          umap[mat[i][j]]={i,j};
      }
   }
   int len=arr.size();
   vector<int> row(m,0); //记录行
   vector<int> col(n,0); //记录列
   int res;
   for(int i=0;i<len;i++)
   {
      row[umap[arr[i]][0]]++;
      col[umap[arr[i]][1]]++;
      if(row[umap[arr[i]][0]]==n||col[umap[arr[i]][1]]==m) 
      //某一行或者某一列被填满
      {
         res=i;
         break;
      }
   }
   return res;
}