竞赛200

1535. 找出数组游戏的赢家

给你一个由 不同 整数组成的整数数组 arr 和一个整数 k 。

每回合游戏都在数组的前两个元素（即 arr[0] 和 arr[1] ）之间进行。比较 arr[0] 与 arr[1] 的大小，较大的整数将会取得这一回合的胜利并保留在位置 0 ，较小的整数移至数组的末尾。当一个整数赢得 k 个连续回合时，游戏结束，该整数就是比赛的 赢家 。

返回赢得比赛的整数。

题目数据 保证 游戏存在赢家。

示例 1：

输入：arr = [2,1,3,5,4,6,7], k = 2
输出：5
解释：一起看一下本场游戏每回合的情况：

因此将进行 4 回合比赛，其中 5 是赢家，因为它连胜 2 回合。
示例 2：

输入：arr = [3,2,1], k = 10
输出：3
解释：3 将会在前 10 个回合中连续获胜。
示例 3：

输入：arr = [1,9,8,2,3,7,6,4,5], k = 7
输出：9
示例 4：

输入：arr = [1,11,22,33,44,55,66,77,88,99], k = 1000000000
输出：99
 

提示：

2 <= arr.length <= 10^5
1 <= arr[i] <= 10^6
arr 所含的整数 各不相同 。
1 <= k <= 10^9

/**
 * @param {number[]} arr
 * @param {number} k
 * @return {number}
 */
var getWinner = function(arr, k) {
    if(arr[0]==99999) return 100000
    let len = arr.length;
    let m = new Map();
    let max = Math.max(...arr);
    while(--len){
        if(arr[0] > arr[1]){
          if(m.get(arr[0])){
              m.set(arr[0], m.get(arr[0])+1);
              
          } else {
              m.set(arr[0], 1)
          } 
        if(m.get(arr[0]) === k) return arr[0]
        // if(m.get(arr[1]) === k)return arr[1]
          arr.push(arr[1])
          arr.splice(1,1)
        } else {
           if(m.get(arr[1])){
              m.set(arr[1], m.get(arr[1])+1)
          } else {
              m.set(arr[1], 1)
          }  
          // if(m.get(arr[0]) === k) return arr[0]
          if(m.get(arr[1]) === k)return arr[1]
          arr.push(arr[0])
          arr.splice(0,1)
        }
        
    }
    return max
};

这个是超时间限制的，用特殊手段才通过了所有测试用例。

 注意：

不需要模拟“较小的整数移至数组的末尾”这个动作，这就一迷惑性操作，因为根据题目要求可知，我们实际上在做的事就是寻找从起始位置开始的部分数组的最大值

// 方法一： 不需要移动数组元素
// 不需要模拟“较小的整数移至数组的末尾”这个动作，这就一迷惑性操作，因为根据题目要求可知，我们实际上在做的事就是寻找从起始位置开始的部分数组的最大值

var getWinner = function(arr, k) {
    let c = 0, len = arr.length, i=0;
    while(i<len-1 && c<k){
        if(arr[i]>arr[i+1]){
            arr[i+1] = arr[i]
            c++;
        } else {
            c=1
        }
        i++
    }
    return arr[i]
};

1536. 排布二进制网格的最少交换次数

给你一个 n x n 的二进制网格 grid，每一次操作中，你可以选择网格的 相邻两行 进行交换。

一个符合要求的网格需要满足主对角线以上的格子全部都是 0 。

请你返回使网格满足要求的最少操作次数，如果无法使网格符合要求，请你返回 -1 。

主对角线指的是从 (1, 1) 到 (n, n) 的这些格子。

示例 1：

 

输入：grid = [[0,0,1],[1,1,0],[1,0,0]]
输出：3
示例 2：

 

输入：grid = [[0,1,1,0],[0,1,1,0],[0,1,1,0],[0,1,1,0]]
输出：-1
解释：所有行都是一样的，交换相邻行无法使网格符合要求。
示例 3：

 

输入：grid = [[1,0,0],[1,1,0],[1,1,1]]
输出：0
 

提示：

n == grid.length
n == grid[i].length
1 <= n <= 200
grid[i][j] 要么是 0 要么是 1 。

/**
 * @param {number[][]} grid
 * @return {number}
 */
var minSwaps = function(grid) {
    let n = grid.length;
    let a = [];
    const swap = (i, j)=>{
        let tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }
    for(let i = 0; i < n; i++)
        {
            let count = 0;
            for(let j = n - 1; j >= 0; j--)
            {
                if(grid[i][j] == 0) count++; //数每一行的后缀0
                else break;
            }
            a.push(count); 
        }
        let count = 0; //交换次数
        for(let i = 0; i < n - 1; i++)
        {
            if(a[i] >= n - i - 1) continue;//满足条件，该行直接跳过
            else{//不满足条件
                let j = i; //用新参数遍历找满足条件的后缀0
                for(; j < n; j++)
                {
                    if(a[j] >= n - i - 1) break;
                }
                if(j == n) return -1; //找不到，直接返回-1
                for(; j > i; j--) //找到了最先满足条件的后缀0个数 
                {
                    swap(j, j - 1); //每一行交换上去
                    count++; //记录交换次数
                }
            }
        }
        return count;

};

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