5726. 数组元素积的符号

题目

已知函数 signFunc(x) 将会根据 x 的正负返回特定值：

• 如果 x 是正数，返回 1 。
• 如果 x 是负数，返回 -1 。
• 如果 x 是等于 0 ，返回 0 。

给你一个整数数组 nums 。令 product 为数组 nums 中所有元素值的乘积。

返回 signFunc(product) 。

示例 1：

输入：nums = [-1,-2,-3,-4,3,2,1]
输出：1
解释：数组中所有值的乘积是 144 ，且 signFunc(144) = 1

示例 2：

输入：nums = [1,5,0,2,-3]
输出：0
解释：数组中所有值的乘积是 0 ，且 signFunc(0) = 0

示例 3：

输入：nums = [-1,1,-1,1,-1]
输出：-1
解释：数组中所有值的乘积是 -1 ，且 signFunc(-1) = -1

提示：

• 1 <= nums.length <= 1000
• -100 <= nums[i] <= 100

思路

• 统计负数个数，如果个数是奇数返回-1，如果个数是偶数返回1，期间如果出现0，直接返回0；

代码

class Solution {
public:
    int arraySign(vector<int>& nums) {
        int cnt = 0;
        for (auto& n : nums) {
            if (n < 0) cnt++;
            if (n == 0) return 0;
        }
        return cnt % 2 == 0 ? 1 : -1;
    }
};

5727. 找出游戏的获胜者

题目

共有 n 名小伙伴一起做游戏。小伙伴们围成一圈，按 顺时针顺序 从 1 到 n 编号。确切地说，从第 i 名小伙伴顺时针移动一位会到达第 (i+1) 名小伙伴的位置，其中 1 <= i < n ，从第 n 名小伙伴顺时针移动一位会回到第 1 名小伙伴的位置。

游戏遵循如下规则：

1. 从第 1 名小伙伴所在位置 开始 。
2. 沿着顺时针方向数 k 名小伙伴，计数时需要 包含 起始时的那位小伙伴。逐个绕圈进行计数，一些小伙伴可能会被数过不止一次。
3. 你数到的最后一名小伙伴需要离开圈子，并视作输掉游戏。
4. 如果圈子中仍然有不止一名小伙伴，从刚刚输掉的小伙伴的 顺时针下一位 小伙伴 开始，回到步骤 2 继续执行。
5. 否则，圈子中最后一名小伙伴赢得游戏。

给你参与游戏的小伙伴总数 n ，和一个整数 k ，返回游戏的获胜者。

示例 1：

输入：n = 5, k = 2
输出：3
解释：游戏运行步骤如下：
1) 从小伙伴 1 开始。
2) 顺时针数 2 名小伙伴，也就是小伙伴 1 和 2 。
3) 小伙伴 2 离开圈子。下一次从小伙伴 3 开始。
4) 顺时针数 2 名小伙伴，也就是小伙伴 3 和 4 。
5) 小伙伴 4 离开圈子。下一次从小伙伴 5 开始。
6) 顺时针数 2 名小伙伴，也就是小伙伴 5 和 1 。
7) 小伙伴 1 离开圈子。下一次从小伙伴 3 开始。
8) 顺时针数 2 名小伙伴，也就是小伙伴 3 和 5 。
9) 小伙伴 5 离开圈子。只剩下小伙伴 3 。所以小伙伴 3 是游戏的获胜者。

示例 2：

输入：n = 6, k = 5
输出：1
解释：小伙伴离开圈子的顺序：5、4、6、2、3 。小伙伴 1 是游戏的获胜者。

提示：

• 1 <= k <= n <= 500

思路

• 由于数据规模不大，可以使用双端队列直接暴力模拟。

• 比赛之后看了下，评论有更好的解法，也就是约瑟夫环——公式法（递推公式）

  • f(N,M)=(f(N−1,M)+M)%N
  • f(N,M)表示，N个人报数，每报到M时退出，最终胜利者的编号
  • f (N−1,M)表示，N-1个人报数，每报到M时退出，最终胜利者的编号

代码

双端队列暴力模拟代码

class Solution {
public:
    int findTheWinner(int n, int k) {
        deque<int> dq;
        for (int i = 1; i <= n; i++) {
            dq.push_back(i);
        }
        for (int v = 1; dq.size() != 1 && v <= k; v++) {
            if (v == k) {
                dq.pop_front();
                v = 0;
            } else {
                int s = dq.front();
                dq.push_back(s);
                dq.pop_front();
            }
        }
        return dq.back();
    }
};

公式法

class Solution {
public:
    int findTheWinner(int n, int k) {
        int x = 0;
        for (int i = 2; i <= n; i++) {
            x = (x + k) % i;
        }
        return x + 1;
    }
};

5728. 最少侧跳次数

题目

给你一个长度为 n 的 3 跑道道路 ，它总共包含 n + 1 个 点 ，编号为 0 到 n 。一只青蛙从 0 号点第二条跑道 出发 ，它想要跳到点 n 处。然而道路上可能有一些障碍。

给你一个长度为 n + 1 的数组 obstacles ，其中 obstacles[i] （取值范围从 0 到 3）表示在点 i 处的 obstacles[i] 跑道上有一个障碍。如果 obstacles[i] == 0 ，那么点 i 处没有障碍。任何一个点的三条跑道中 最多有一个 障碍。

• 比方说，如果 obstacles[2] == 1 ，那么说明在点 2 处跑道 1 有障碍。

这只青蛙从点 i 跳到点 i + 1 且跑道不变的前提是点 i + 1 的同一跑道上没有障碍。为了躲避障碍，这只青蛙也可以在 同一个 点处 侧跳 到 另外一条 跑道（这两条跑道可以不相邻），但前提是跳过去的跑道该点处没有障碍。

• 比方说，这只青蛙可以从点 3 处的跑道 3 跳到点 3 处的跑道 1 。

这只青蛙从点 0 处跑道 2 出发，并想到达点 n 处的 任一跑道 ，请你返回 最少侧跳次数 。

注意：点 0 处和点 n 处的任一跑道都不会有障碍。

示例 1：

输入：obstacles = [0,1,2,3,0]
输出：2 
解释：最优方案如上图箭头所示。总共有 2 次侧跳（红色箭头）。
注意，这只青蛙只有当侧跳时才可以跳过障碍（如上图点 2 处所示）。

示例 2：

输入：obstacles = [0,1,1,3,3,0]
输出：0
解释：跑道 2 没有任何障碍，所以不需要任何侧跳。

示例 3：

输入：obstacles = [0,2,1,0,3,0]
输出：2
解释：最优方案如上图所示。总共有 2 次侧跳。

提示：

• obstacles.length == n + 1
• 1 <= n <= 5 * 105
• 0 <= obstacles[i] <= 3
• obstacles[0] == obstacles[n] == 0

思路

• 动态规划（DP）

  • 初始状态：第一列初始化为 1、 0、 1 ，因为第一列会影响到第二列，所以第二列初始化条件就是：如果第二列的某一行是石头，就不需要初始化，否则等于第一列的

  • 状态转移方程：

    • 第一行：dp[row][col] = min(dp[row + 2][col] + 1, dp[row][col - 1], dp[row + 1][col] + 1);
    • 第二行：dp[row][col] = min(dp[row + 1][col] + 1, dp[row][col - 1], dp[row - 1][col] + 1);
    • 第三行：dp[row][col] = min(dp[row - 2][col] + 1 ,dp[row][col - 1], dp[row - 1][col] + 1);

  • 然后更新下一列：

    • 如果下一列是石头，则下一列的值不能被更新
    • 如果下一列不是石头，则下一列的值等于当前值 dp[row][col + 1] = dp[row][col];

以[0,1,2,3,0]为例，dp数组为：

1	M	2	2	2	2
0	0	M	3	3	3
1	1	1	M	3	3

返回最后一列的最小值即可

代码

int MAX = INT_MAX - 1;
class Solution {
public:
    int minSideJumps(vector<int>& b) {
        int n = b.size();
        vector<vector<int>> dp(3, vector<int> (n + 1));
        dp[0][0] = 1,dp[1][0] = 0,dp[2][0] = 1;
        for (int i = 0; i < b.size(); i++) {
            if (b[i] != 0) dp[b[i] - 1][i] = MAX;
        }
        dp[0][1] == MAX ? MAX : 1;
        dp[1][1] == MAX ? MAX : 0;
        dp[2][1] == MAX ? MAX : 1;
        for (int col = 1; col < n; col++) {
            for (int row = 0; row < 3; row++) {
                if(dp[row][col] == MAX) {
                    if (dp[row][col + 1] != MAX) dp[row][col + 1] = MAX - 100;
                    continue;
                }
                if (row == 0) dp[row][col] = min(dp[row + 2][col] + 1,min(dp[row][col - 1], dp[row + 1][col] + 1));
                else if (row == 1) dp[row][col] = min(dp[row + 1][col] + 1, min(dp[row][col - 1], dp[row - 1][col] + 1));
                else dp[row][col] = min(dp[row - 2][col] + 1 ,min(dp[row][col - 1], dp[row - 1][col] + 1));
                if (dp[row][col + 1] != MAX)
                    dp[row][col + 1] = dp[row][col]; 
            }
        }
        return min(dp[2][n], min(dp[0][n], dp[1][n]));
    }
};

5729. 求出 MK 平均值

题目

给你两个整数 m 和 k ，以及数据流形式的若干整数。你需要实现一个数据结构，计算这个数据流的 MK 平均值 。

MK 平均值 按照如下步骤计算：

1. 如果数据流中的整数少于 m 个，MK 平均值 为 -1 ，否则将数据流中最后 m 个元素拷贝到一个独立的容器中。
2. 从这个容器中删除最小的 k 个数和最大的 k 个数。
3. 计算剩余元素的平均值，并 向下取整到最近的整数 。

请你实现 MKAverage 类：

• MKAverage(int m, int k) 用一个空的数据流和两个整数 m 和 k 初始化 MKAverage 对象。

• void addElement(int num) 往数据流中插入一个新的元素 num 。

• int calculateMKAverage() 对当前的数据流计算并返回 MK 平均数 ，结果需 向下取整到最近的整数 。

示例 1：

输入：
["MKAverage", "addElement", "addElement", "calculateMKAverage", "addElement", "calculateMKAverage", "addElement", "addElement", "addElement", "calculateMKAverage"]
[[3, 1], [3], [1], [], [10], [], [5], [5], [5], []]
输出：
[null, null, null, -1, null, 3, null, null, null, 5]

解释：
MKAverage obj = new MKAverage(3, 1); 
obj.addElement(3);        // 当前元素为 [3]
obj.addElement(1);        // 当前元素为 [3,1]
obj.calculateMKAverage(); // 返回 -1 ，因为 m = 3 ，但数据流中只有 2 个元素
obj.addElement(10);       // 当前元素为 [3,1,10]
obj.calculateMKAverage(); // 最后 3 个元素为 [3,1,10]
                          // 删除最小以及最大的 1 个元素后，容器为 [3]
                          // [3] 的平均值等于 3/1 = 3 ，故返回 3
obj.addElement(5);        // 当前元素为 [3,1,10,5]
obj.addElement(5);        // 当前元素为 [3,1,10,5,5]
obj.addElement(5);        // 当前元素为 [3,1,10,5,5,5]
obj.calculateMKAverage(); // 最后 3 个元素为 [5,5,5]
                          // 删除最小以及最大的 1 个元素后，容器为 [5]
                          // [5] 的平均值等于 5/1 = 5 ，故返回 5

提示：

• 3 <= m <= 105
• 1 <= k*2 < m
• 1 <= num <= 105
• addElement 与 calculateMKAverage 总操作次数不超过 105 次。

思路

维护 3 个 multiset：lower（保存最小的 kk 个数）、middle（中间的数）、upper（保存最大的 kk 个数）。

插入操作

• 如果 num≤max(lower)，则在 lower中插入 num
• 如果 num≥min(upper)，则在 upper 中插入 num
• 否则，在 middle中插入 num 如果插入后，lower 或 upper 中的元素多于 k 个，则向 middle 中 转移 元素

操作过程中维护 middle 的元素和 sum

删除操作

• 设删除的元素为 d
• d 一定存在于 lower 或 middle 或 upper 中的一个或多个集合中
• 选择一删除即可
• 如果删除后，lower 或 upper 中的元素少于 k 个，则从 middle中 索取 元素

操作过程中维护 middle 的元素和 sum

平均值操作 平均值 = sum/(m−2⋅k) （向下取整）。

代码

这道题没ac，所以直接贴出大佬的代码；leetcode-cn.com/problems/fi…

class MKAverage {
public:
    long long m, k, sum = 0;
    multiset<int> lower, middle, upper;
    queue<int> nums;
    
    MKAverage(int m, int k) {
        this->m = m;
        this->k = k;
    }
    
    void shiftLeft(multiset<int>& l, multiset<int>& r) {
        l.insert(*r.begin());
        r.erase(r.begin());
    }
    
    void shiftRight(multiset<int>& l, multiset<int>& r) {
        r.insert(*l.rbegin());
        l.erase(--l.end());
    }
    
    void addElement(int num) {
        nums.push(num);
        
        if(lower.size() && *lower.rbegin() >= num) lower.insert(num);
        else if(upper.size() && *upper.begin() <= num) upper.insert(num);
        else middle.insert(num), sum += num;
        
        while(lower.size() > k) sum += *lower.rbegin(), shiftRight(lower, middle);
        while(upper.size() > k) sum += *upper.begin(), shiftLeft(middle, upper);
        
        if(nums.size() > m) {
            int d = nums.front(); nums.pop();
            if(lower.find(d) != lower.end()) lower.erase(lower.find(d));
            else if(middle.find(d) != middle.end()) middle.erase(middle.find(d)), sum -= d;
            else upper.erase(upper.find(d));
        }
        
        if(nums.size() >= m) {
            while(lower.size() < k) sum -= *middle.begin(), shiftLeft(lower, middle);
            while(upper.size() < k) sum -= *middle.rbegin(), shiftRight(middle, upper);
        }
    }
    
    int calculateMKAverage() {
        if(nums.size() < m) return -1;
        return sum / (m - 2*k);
    }
};