LeetCode 904. 水果成篮 / 907. 子数组的最小值之和（单调栈+动态规划） / 481. 神奇字符串

Posted 2022-11-28 Zephyr丶J

904. 水果成篮

题目描述

你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。

你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：

• 你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
• 你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
• 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
  给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。

示例 1：

输入：fruits = [1,2,1]
输出：3
解释：可以采摘全部 3 棵树。

示例 2：

输入：fruits = [0,1,2,2]
输出：3
解释：可以采摘 [1,2,2] 这三棵树。
如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。

示例 3：

输入：fruits = [1,2,3,2,2]
输出：4
解释：可以采摘 [2,3,2,2] 这四棵树。
如果从第一棵树开始采摘，则只能采摘 [1,2] 这两棵树。

示例 4：

输入：fruits = [3,3,3,1,2,1,1,2,3,3,4]
输出：5
解释：可以采摘 [1,2,1,1,2] 这五棵树。

提示：

1 <= fruits.length <= 10^5
0 <= fruits[i] < fruits.length

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

思路

滑动窗口，我这里是用两个变量记录的，答案里更多是哈希表

class Solution:
    def totalFruit(self, fruits: List[int]) -> int:
        # 就是找到一个区间，在这个区间内，只有两种树
        # 其实就是用滑动窗口，记录每种树在当前区段的开始和结束
        # 好像只需要记录最后一段连续的数字长度就可以了
        type1 = -1
        type2 = -1
        continues = 0   # 记录连续的数量
        temp = 0
        maxcount = 0
        last = -1   # 上一个水果种类

        for f in fruits:
            # 如果是刚开始第一个，那么赋值
            if type1 == -1:
                type1 = f
                temp += 1
                last = f
                continues = 1

            # 如果是第二个种类的水果，那么赋值，并将last置为1
            elif f != type1 and type2 == -1:
                type2 = f
                temp += 1
                last = f
                continues = 1
            # 如果是之前出现过的水果
            elif f == type1 or f == type2:
                temp += 1
                # 如果是连续的水果，那么加1
                if last == f:
                    continues += 1
                # 否则重置连续的水果种类
                else:
                    last = f
                    continues = 1
            # 如果不是这两种类型的水果
            else:
                maxcount = max(maxcount, temp)
                temp = continues + 1
                type1, type2 = last, f
                last = f
                continues = 1
    
        maxcount = max(maxcount, temp)
        return maxcount               

907. 子数组的最小值之和

2022.10.28 每日一题

题目描述

给定一个整数数组 arr，找到 min(b) 的总和，其中 b 的范围为 arr 的每个（连续）子数组。

由于答案可能很大，因此 返回答案模 10^9 + 7 。

示例 1：

输入：arr = [3,1,2,4]
输出：17
解释：
子数组为 [3]，[1]，[2]，[4]，[3,1]，[1,2]，[2,4]，[3,1,2]，[1,2,4]，[3,1,2,4]。
最小值为 3，1，2，4，1，1，2，1，1，1，和为 17。

示例 2：

输入：arr = [11,81,94,43,3]
输出：444

提示：

1 <= arr.length <= 3 * 10^4
1 <= arr[i] <= 3 * 10^4

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

思路

单调栈+动态规划
其实还是比较难的
最后出现的问题竟然是我把10^9认为是10e9了。。。就说怎么一直不对

class Solution 
    public static final int mod = (int)1e9 + 7;
    public int sumSubarrayMins(int[] arr) 
        //统计以每个位置结尾的子数组最小值，好像不太行
        //想到一个单调栈的，每次遍历到一个数就统计以当前数为结尾的最小值之和
        //就是看到比栈顶top小的数temp，top就出栈，然后由于出栈前面的都是以

        //统计统计以每个位置结尾的子数组最小值之和
        //如果当前值比之前最小值要小,那么就是i个temp相乘
        //如果比之前的最小值要大，因为前一个已经计算完成了，所以就直接dp[i-1]+temp
        //不行，因为如果存在一个中间数，计算就是错误的

        //还是想想单调栈，如果遇到大的，就入栈，然后统计当前和
        //如果遇到小的，要知道从哪开始是小的，所以单调栈是合适的

        int l = arr.length;
        
        Deque<Integer> stack = new LinkedList<>();

        long sum = arr[0];
        long[] f = new long[l];
        f[0] = arr[0];     //以当前结尾的子数组和
        stack.offer(0);

        for(int i = 1; i < l; i++)
            if(arr[i] >= arr[stack.peekLast()])
                f[i] = f[i - 1] + arr[i];
                stack.offer(i);
            //如果小于的时候，需要看小的位置在哪里
            else
                int temp = 0;
                while(!stack.isEmpty() && arr[i] < arr[stack.peekLast()])
                    temp = stack.pollLast();
                
                temp = !stack.isEmpty() ? stack.peekLast() : -1;
                //当前找到了位置，那么从这个位置之前，还是不变；
                //这个位置之后，就发生了改变
                stack.offer(i);
                if(temp == -1)
                    f[i] = arr[i] * (i + 1); 
                else
                    f[i] = f[temp] + arr[i] * (i - temp);
                
            
            sum = (sum + f[i]) % mod;
        
        return (int)sum;
    

class Solution:
    def sumSubarrayMins(self, arr: List[int]) -> int:
        mod = 10 ** 9 + 7
        l = len(arr)
        f = [0] * l
        stack = [0]
        f[0] = arr[0]
        sum = 0
        for i, a in enumerate(arr):
            while len(stack) > 0 and a < arr[stack[-1]]:
                stack.pop()
            temp = stack[-1] if len(stack) > 0 else -1
            f[i] = a * (i - temp) + f[temp] if temp != -1 else a * (i + 1)
            sum += f[i]
            stack.append(i)
        return sum % mod

481. 神奇字符串

2022.10.31 每日一题，又是周而复始的一周

题目描述

神奇字符串 s 仅由 ‘1’ 和 ‘2’ 组成，并需要遵守下面的规则：

• 神奇字符串 s 的神奇之处在于，串联字符串中 ‘1’ 和 ‘2’ 的连续出现次数可以生成该字符串。

s 的前几个元素是 s = “1221121221221121122……” 。如果将 s 中连续的若干 1 和 2 进行分组，可以得到 “1 22 11 2 1 22 1 22 11 2 11 22 …” 。每组中 1 或者 2 的出现次数分别是 “1 2 2 1 1 2 1 2 2 1 2 2 …” 。上面的出现次数正是 s 自身。

给你一个整数 n ，返回在神奇字符串 s 的前 n 个数字中 1 的数目。

示例 1：

输入：n = 6
输出：3
解释：神奇字符串 s 的前 6 个元素是 “122112”，它包含三个 1，因此返回 3 。

示例 2：

输入：n = 1
输出：1

提示：

1 <= n <= 10^5

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

思路

理解了题意以后，就是一个简单的模拟题

class Solution:
    def magicalString(self, n: int) -> int:
        # 看了半天没看懂啥意思，终于看懂了也一下子不知道怎么下手
        # 不过应该有规律的吧
        # 1 2 2 1 1 2 1 2 2 1 2 2 1 1 2 1 1 2 2 1 2 1 1 2 1 2 2 1 1 2 1 1 2 1 2 2
        # 1 2 2 1 1 2 1 2 2 1 2 2 1 1 2 1 1 2 2 1 2 1 1 2 

        # 写了一串找不到规律，那就一步步来吧
        # 从两位开始就能依次往后面推了，不，三位更好写一点

        if n <= 3:
            return 1
        s1 = '122'
        s2 = '12'
        idx = 2
        temp = -1
        while len(s1) < n:
            temp = int(s1[idx])
            if s1[-1] == '1':
                s1 = s1 +temp * '2'
            else:
                s1 = s1 + temp * '1'
            idx += 1
        res = 0
        for a in s1[:n]:
            if a == '1':
                res += 1
        
        return res