0%

    10038. 执行操作后的最大分割数量


    给你一个下标从 0 开始的字符串 s 和一个整数 k

    你需要执行以下分割操作,直到字符串 s 变为 

    • 选择 s 的最长前缀,该前缀最多包含 k 个 不同 字符。

    • 删除 这个前缀,并将分割数量加一。如果有剩余字符,它们在 s 中保持原来的顺序。

    执行操作之 ,你可以将 s 中 至多一处 下标的对应字符更改为另一个小写英文字母。

    在最优选择情形下改变至多一处下标对应字符后,用整数表示并返回操作结束时得到的最大分割数量。

    示例 1:

    ```txt

    输入:s = "accca", k = 2

    输出:3

    解释:在此示例中,为了最大化得到的分割数量,可以将 s[2] 改为 'b'。

    s 变为 "acbca"。

    按照以下方式执行操作,直到 s 变为空:

    • 选择最长且至多包含 2 个不同字符的前缀,"acbca"。

    • 删除该前缀,s 变为 "bca"。现在分割数量为 1。

    • 选择最长且至多包含 2 个不同字符的前缀,"bca"。

    • 删除该前缀,s 变为 "a"。现在分割数量为 2。

    • 选择最长且至多包含 2 个不同字符的前缀,"a"。

    • 删除该前缀,s 变为空。现在分割数量为 3。

    因此,答案是 3。

    可以证明,分割数量不可能超过 3。

    ```

    示例 2:

    ```txt

    输入:s = "aabaab", k = 3

    输出:1

    解释:在此示例中,为了最大化得到的分割数量,可以保持 s 不变。

    按照以下方式执行操作,直到 s 变为空:

    • 选择最长且至多包含 3 个不同字符的前缀,"aabaab"。

    • 删除该前缀,s 变为空。现在分割数量为 1。

    因此,答案是 1。

    可以证明,分割数量不可能超过 1。

    ```

    示例 3:

    ```txt

    输入:s = "xxyz", k = 1

    输出:4

    解释:在此示例中,为了最大化得到的分割数量,可以将 s[1] 改为 'a'。

    s 变为 "xayz"。

    按照以下方式执行操作,直到 s 变为空:

    • 选择最长且至多包含 1 个不同字符的前缀,"xayz"。

    • 删除该前缀,s 变为 "ayz"。现在分割数量为 1。

    • 选择最长且至多包含 1 个不同字符的前缀,"ayz"。

    • 删除该前缀,s 变为 "yz",现在分割数量为 2。

    • 选择最长且至多包含 1 个不同字符的前缀,"yz"。

    • 删除该前缀,s 变为 "z"。现在分割数量为 3。

    • 选择最且至多包含 1 个不同字符的前缀,"z"。

    • 删除该前缀,s 变为空。现在分割数量为 4。

    因此,答案是 4。

    可以证明,分割数量不可能超过 4。

    ```

    提示:

    • 1 <= s.length <= 10^4

    • s 只包含小写英文字母。

    • 1 <= k <= 26

阅读全文 »

    2547. 拆分数组的最小代价


    给你一个整数数组 nums 和一个整数 k

    将数组拆分成一些非空子数组。拆分的 代价 是每个子数组中的 重要性 之和。

    trimmed(subarray) 作为子数组的一个特征,其中所有仅出现一次的数字将会被移除。

    • 例如,trimmed([3,1,2,4,3,4]) = [3,4,3,4]

    子数组的 重要性 定义为 k + trimmed(subarray).length

    • 例如,如果一个子数组是 [1,2,3,3,3,4,4]trimmed([1,2,3,3,3,4,4]) = [3,3,3,4,4] 。这个子数组的重要性就是 k + 5

    找出并返回拆分 nums 的所有可行方案中的最小代价。

    子数组 是数组的一个连续 非空 元素序列。

    示例 1:

    ```txt

    输入:nums = [1,2,1,2,1,3,3], k = 2

    输出:8

    解释:将 nums 拆分成两个子数组:[1,2], [1,2,1,3,3]

    [1,2] 的重要性是 2 + (0) = 2 。

    [1,2,1,3,3] 的重要性是 2 + (2 + 2) = 6 。

    拆分的代价是 2 + 6 = 8 ,可以证明这是所有可行的拆分方案中的最小代价。

    ```

    示例 2:

    ```txt

    输入:nums = [1,2,1,2,1], k = 2

    输出:6

    解释:将 nums 拆分成两个子数组:[1,2], [1,2,1] 。

    [1,2] 的重要性是 2 + (0) = 2 。

    [1,2,1] 的重要性是 2 + (2) = 4 。

    拆分的代价是 2 + 4 = 6 ,可以证明这是所有可行的拆分方案中的最小代价。

    ```

    示例 3:

    ```txt

    输入:nums = [1,2,1,2,1], k = 5

    输出:10

    解释:将 nums 拆分成一个子数组:[1,2,1,2,1].

    [1,2,1,2,1] 的重要性是 5 + (3 + 2) = 10 。

    拆分的代价是 10 ,可以证明这是所有可行的拆分方案中的最小代价。

    ```

    提示:

    • 1 <= nums.length <= 1000

    • 0 <= nums[i] < nums.length

    • 1 <= k <= 10^9

阅读全文 »

    1824. 最少侧跳次数


    给你一个长度为 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:

    ```txt

    输入:obstacles = [0,1,2,3,0]

    输出:2

    解释:最优方案如上图箭头所示。总共有 2 次侧跳(红色箭头)。

    注意,这只青蛙只有当侧跳时才可以跳过障碍(如上图点 2 处所示)。

    ```

    示例 2:

    ```txt

    输入:obstacles = [0,1,1,3,3,0]

    输出:0

    解释:跑道 2 没有任何障碍,所以不需要任何侧跳。

    ```

    示例 3:

    ```txt

    输入:obstacles = [0,2,1,0,3,0]

    输出:2

    解释:最优方案如上图所示。总共有 2 次侧跳。

    ```

    提示:

    • obstacles.length == n + 1

    • 1 <= n <= 5 * 10^5

    • 0 <= obstacles[i] <= 3

    • obstacles[0] == obstacles[n] == 0

阅读全文 »

    2167. 移除所有载有违禁货物车厢所需的最少时间


    给你一个下标从 0 开始的二进制字符串 s ,表示一个列车车厢序列。s[i] = '0' 表示第 i 节车厢 含违禁货物,而 s[i] = '1' 表示第 i 节车厢含违禁货物。

    作为列车长,你需要清理掉所有载有违禁货物的车厢。你可以不限次数执行下述三种操作中的任意一个:

    1. 从列车 端移除一节车厢(即移除 s[0]),用去 1 单位时间。

    2. 从列车 端移除一节车厢(即移除 s[s.length - 1]),用去 1 单位时间。

    3. 从列车车厢序列的 任意位置 移除一节车厢,用去 2 单位时间。

    返回移除所有载有违禁货物车厢所需要的 最少 单位时间数。

    注意,空的列车车厢序列视为没有车厢含违禁货物。

    示例 1:

    ```txt

    输入:s = "1100101"

    输出:5

    解释:

    一种从序列中移除所有载有违禁货物的车厢的方法是:

    • 从左端移除一节车厢 2 次。所用时间是 2 * 1 = 2 。

    • 从右端移除一节车厢 1 次。所用时间是 1 。

    • 移除序列中间位置载有违禁货物的车厢。所用时间是 2 。

    总时间是 2 + 1 + 2 = 5 。

    一种替代方法是:

    • 从左端移除一节车厢 2 次。所用时间是 2 * 1 = 2 。

    • 从右端移除一节车厢 3 次。所用时间是 3 * 1 = 3 。

    总时间也是 2 + 3 = 5 。

    5 是移除所有载有违禁货物的车厢所需要的最少单位时间数。

    没有其他方法能够用更少的时间移除这些车厢。

    ```

    示例 2:

    ```txt

    输入:s = "0010"

    输出:2

    解释:

    一种从序列中移除所有载有违禁货物的车厢的方法是:

    • 从左端移除一节车厢 3 次。所用时间是 3 * 1 = 3 。

    总时间是 3.

    另一种从序列中移除所有载有违禁货物的车厢的方法是:

    • 移除序列中间位置载有违禁货物的车厢。所用时间是 2 。

    总时间是 2.

    另一种从序列中移除所有载有违禁货物的车厢的方法是:

    • 从右端移除一节车厢 2 次。所用时间是 2 * 1 = 2 。

    总时间是 2.

    2 是移除所有载有违禁货物的车厢所需要的最少单位时间数。

    没有其他方法能够用更少的时间移除这些车厢。

    ```

    提示:

    • 1 <= s.length <= 2 * 10^5

    • s[i]'0''1'

阅读全文 »

    2484. 统计回文子序列数目


    给你数字字符串 s ,请你返回 s 中长度为 5 的 回文子序列 数目。由于答案可能很大,请你将答案对 10^9 + 7 取余 后返回。

    提示:

    • 如果一个字符串从前往后和从后往前读相同,那么它是 回文字符串 。

    • 子序列是一个字符串中删除若干个字符后,不改变字符顺序,剩余字符构成的字符串。

    示例 1:

    ```txt

    输入:s = "103301"

    输出:2

    解释:

    总共有 6 长度为 5 的子序列:"10330" ,"10331" ,"10301" ,"10301" ,"13301" ,"03301" 。

    它们中有两个(都是 "10301")是回文的。

    ```

    示例 2:

    ```txt

    输入:s = "0000000"

    输出:21

    解释:所有 21 个长度为 5 的子序列都是 "00000" ,都是回文的。

    ```

    示例 3:

    ```txt

    输入:s = "9999900000"

    输出:2

    解释:仅有的两个回文子序列是 "99999" 和 "00000" 。

    ```

    提示:

    • 1 <= s.length <= 10^4

    • s 只包含数字字符。

阅读全文 »

    6352. 美丽子集的数目


    给你一个由正整数组成的数组 nums 和一个 整数 k

    如果 nums 的子集中,任意两个整数的绝对差均不等于 k ,则认为该子数组是一个 美丽 子集。

    返回数组 nums非空美丽 的子集数目。

    nums 的子集定义为:可以经由 nums 删除某些元素(也可能不删除)得到的一个数组。只有在删除元素时选择的索引不同的情况下,两个子集才会被视作是不同的子集。

    示例 1:

    ```txt

    输入:nums = [2,4,6], k = 2

    输出:4

    解释:数组 nums 中的美丽子集有:[2], [4], [6], [2, 6] 。

    可以证明数组 [2,4,6] 中只存在 4 个美丽子集。

    ```

    示例 2:

    ```txt

    输入:nums = [1], k = 1

    输出:1

    解释:数组 nums 中的美丽数组有:[1] 。

    可以证明数组 [1] 中只存在 1 个美丽子集。

    ```

    提示:

    • 1 <= nums.length <= 20

    • 1 <= nums[i], k <= 1000

阅读全文 »

    1997. 访问完所有房间的第一天


    你需要访问 n 个房间,房间从 0n - 1 编号。同时,每一天都有一个日期编号,从 0 开始,依天数递增。你每天都会访问一个房间。

    最开始的第 0 天,你访问 0 号房间。给你一个长度为 n下标从 0 开始 的数组 nextVisit 。在接下来的几天中,你访问房间的 次序 将根据下面的 规则 决定:

    • 假设某一天,你访问 i 号房间。

    • 如果算上本次访问,访问 i 号房间的次数为 奇数 ,那么 第二天 需要访问 nextVisit[i] 所指定的房间,其中 0 <= nextVisit[i] <= i

    • 如果算上本次访问,访问 i 号房间的次数为 偶数 ,那么 第二天 需要访问 (i + 1) mod n 号房间。

    请返回你访问完所有房间的第一天的日期编号。题目数据保证总是存在这样的一天。由于答案可能很大,返回对 10^9 + 7 取余后的结果。

    示例 1:

    ```txt

    输入:nextVisit = [0,0]

    输出:2

    解释:

    • 第 0 天,你访问房间 0 。访问 0 号房间的总次数为 1 ,次数为奇数。

    下一天你需要访问房间的编号是 nextVisit[0] = 0

    • 第 1 天,你访问房间 0 。访问 0 号房间的总次数为 2 ,次数为偶数。

    下一天你需要访问房间的编号是 (0 + 1) mod 2 = 1

    • 第 2 天,你访问房间 1 。这是你第一次完成访问所有房间的那天。

    ```

    示例 2:

    ```txt

    输入:nextVisit = [0,0,2]

    输出:6

    解释:

    你每天访问房间的次序是 [0,0,1,0,0,1,2,...] 。

    第 6 天是你访问完所有房间的第一天。

    ```

    示例 3:

    ```txt

    输入:nextVisit = [0,1,2,0]

    输出:6

    解释:

    你每天访问房间的次序是 [0,0,1,1,2,2,3,...] 。

    第 6 天是你访问完所有房间的第一天。

    ```

    提示:

    • n == nextVisit.length

    • 2 <= n <= 10^5

    • 0 <= nextVisit[i] <= i

阅读全文 »