力扣周赛：力扣第407场周赛

字节幺零二四

于 2024-07-21 19:32:11 发布

阅读量392

点赞数 7

分类专栏：算法竞赛文章标签： leetcode 算法

本文链接：https://blog.csdn.net/qq_53469830/article/details/140592490

版权

算法竞赛专栏收录该内容

6 篇文章 0 订阅

订阅专栏

力扣第407场周赛：将 1 移动到末尾的最大操作次数、使数组等于目标数组所需的最少操作次数，涉及思维、单调栈、分类讨论等知识点。

T3-将 1 移动到末尾的最大操作次数

题目描述

给你一个二进制字符串 $s$ 。

你可以对这个字符串执行任意次下述操作：

选择字符串中的任一下标 $i$ （ $i + 1 < s . l e n g t h$ ），该下标满足 $s [i] == 1 且 s [i + 1] == 0$ 。
将字符 $s [i]$ 向右移直到它到达字符串的末端或另一个 $1$ 。

例如，对于 $s$ = “010010”，如果我们选择 $i = 1$ ，结果字符串将会是 $s$ = “000110”。

返回你能执行的最大操作次数。

数据范围

$1 <= s.length <= 10^5$
$s [i]$ 为 $0$ 或 $1$ 。

解题思路

考虑如下移动方案

移动第 $1$ 个 $1$ ，操作次数合计为 $1$ ；
移动第 $2$ 个 $1$ ，然后又可以移动第 $1$ 个 $1$ ，操作次数合计为 $2$ ；
移动第 $3$ 个 $1$ ，然后又可以移动第 $2$ 个 $1$ ，然后又可以移动第 $1$ 个 $1$ ，操作次数合计为 $3$ ；
以此类推。

注意，并非每个 $1$ 都可以移动。

代码实现

int maxOperations(string s) {
    int n = s.size(), res = 0, r = n - 1, c1 = 0;
    for (int i = 0; i < r; i++) {
        if (s[i] == '1') {
            // 记录当前1的个数
            c1++;
            // 1的后面如果是0，则现在可以移动
            if (s[i + 1] == '0')res += c1;
        }
    }
    return res;
}

时间复杂度： $O (n)$ 。

空间复杂度： $O (1)$ 。

T4-使数组等于目标数组所需的最少操作次数

题目描述

给你两个长度相同的正整数数组 $n u m s$ 和 $t a r g e t$ 。

在一次操作中，你可以选择 $n u m s$ 的任何子数组，并将该子数组内的每个元素的值增加或减少 1。

返回使 $n u m s$ 数组变为 $t a r g e t$ 数组所需的最少操作次数。

数据范围

$1 <= nums.length == target.length <= 10^5$
$1 <= nums[i], target[i] <= 10^8$

解题思路

令 $v [i] = n u m [i] - t a r g e t [i]$ ，要使得 $n u m s$ 变为 $t a r g e t$ ，等价于使得 $v [i]$ 全为 $0$ 。

$v [i]$ 由若干如下数段组成：连续正数段、连续负数段、连续 $0$ 段。

注意，数段需满足与数段相邻的数的符号与数段不同， $0$ 既不是正数也不是负数。举个例子，若连续正数段 $a$ 和 $b$ 相邻，则 $a$ 和 $b$ 应视为一个连续正数段。

对于每个数段，单独处理。既然数段之间互不影响，则可将连续负数段转为连续正数段处理，又由于连续 $0$ 段已满足题目要求，故不处理。所以，只需要处理连续正数段即可。

连续且相等的若干个数可视作同一个数，视作同一个数不影响操作次数。

准备单调栈 $s k$ ，对于一个连续正数段 $a$ ，考虑将 $a_i$ 入栈：

若栈为空或者 $a_i>sk.top$ ，则直接入栈。
否则，若 $a_i=sk.top$ ，可视作同一个数， $a_i$ 不入栈，忽略。
否则，令 $x = s k . t o p$ ，栈顶元素出栈
- 若栈为空，则操作 $x-a_i$ 次，使得 $x$ 变成 $a_i$ ， $a_i$ 入栈。 $x$ 和 $a_i$ 现在被视作同一个数，仅让 $a_i$ 留在栈中即可，后续不用考虑 $x$ 。
- 若栈不为空，则比较 $s k . t o p$ 和 $a_i$
  - 若 $sk.top＞a_i$ ，则操作 $x - s k . t o p$ 次，将 $x$ 变成 $s k . t o p$ ，回到步骤 $1$ 。
  - 否则，操作 $x-a_i$ 次，将 $x$ 变成 $a_i$ ，若 $a_i!=sk.top$ 则入栈，否则忽略。

代码实现

long long minimumOperations(vector<int> &nums, vector<int> &target) {
    typedef long long ll;
    int n = nums.size();
    auto &v = nums;
    for (int i = 0; i < n; i++)v[i] -= target[i];
    // 逐一处理每段
    int l = 0, r, sk[n], tp;
    ll res = 0;
    while (l < n) {
        // 重置栈指针
        tp = -1;
        // 找非零段
        while (l < n && !v[l])l++;
        if ((r = l) >= n)break;
        // 处理非零段
        for (int tv; r < n && v[r] && (v[l] ^ v[r]) >= 0; r++) {
            tv = abs(v[r]);
            while (tp != -1 && sk[tp] > tv) {
                int x = sk[tp--];
                if (tp == -1 || sk[tp] < tv)res += x - tv;
                else res += x - sk[tp];
            }
            // 待入栈元素与栈顶元素相同时无需入栈
            if (tp == -1 || sk[tp] != v[r]) sk[++tp] = tv;
        }
        // 处理栈中剩余元素
        while (tp != -1) {
            int x = sk[tp--];
            res += tp == -1 ? x : x - sk[tp];
        }
        // 换下一个区间
        l = r;
    }
    return res;
}

时间复杂度： $O (n)$ ，每个元素最多入栈 $1$ 次、出栈 $1$ 次。