牛客小白月赛86 解题报告 | 珂学家 | 最大子数组和变体 + lazy线段树&动态区间树

最新推荐文章于 2024-07-25 11:27:31 发布
最新推荐文章于 2024-07-25 11:27:31 发布
阅读量439 收藏 9
点赞数 8
文章标签： 算法 力扣 java leetcode python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66102593/article/details/135715225
版权

前言

在这里插入图片描述

整体评价

终于回归小白月赛的内核了，希望以后也继续保持，_.

A. 水盐平衡

思路: 模拟

题目保证没有浓度相等的情况

盐度 a/b， c/d 的比较关系

演变为 ad, bc 两者的大小关系

#include <bits/stdc++.h>

using namespace std;

int main() {
    int t;
    cin >> t;
    while (t-- > 0) {
        int a, b, c, d;
        cin >> a >> b >> c >> d;
        if (a * d > b * c) {
            cout << "S" << endl;
        } else {
            cout << "Y" << endl;
        }
    }
    return 0;
}

B. 水平考试

思路: 位运算

s, t可以转化为二进制形态

s为t的一个子集，其实表示为

然后 s & t == s

或者 s | t == t

两者皆可

t = int(input())

def mask(s: str) -> int:
    r = 0
    for c in s:
        r |= 1 << (ord(c) - ord('A'))
    return r

for i in range(t):
    s, t = input(), input()
    a, b = mask(s), mask(t)
    if a & b == a:
        print (10)
    else:
        print (0)

C. 数组段数

思路: 分段编码

给每个区间一个递增的编号

然后 id(e) - id(s) + 1

方法二, 利用区间前缀和作差，时间复杂度可以少一个log

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class Main {

    public static void main(String[] args) {
        AReader sc = new AReader();
        int n = sc.nextInt(), m = sc.nextInt();

        TreeMap<Integer, Integer> tree = new TreeMap<>();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }

        int segId = 0;
        int j = 0;
        while (j < n) {
            int k = j + 1;
            while (k < n && arr[k - 1] == arr[k]) {
                k++;
            }
            tree.put(j, segId++);
            j = k;
        }

        for (int i =0; i < m; i++) {
            int l = sc.nextInt() - 1, r = sc.nextInt() - 1;
            int res = tree.floorEntry(r).getValue() - tree.floorEntry(l).getValue() + 1;
            System.out.println(res);
        }

    }

    static
    class AReader {
        private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        private StringTokenizer tokenizer = new StringTokenizer("");
        private String innerNextLine() {
            try {
                return reader.readLine();
            } catch (IOException ex) {
                return null;
            }
        }
        public boolean hasNext() {
            while (!tokenizer.hasMoreTokens()) {
                String nextLine = innerNextLine();
                if (nextLine == null) {
                    return false;
                }
                tokenizer = new StringTokenizer(nextLine);
            }
            return true;
        }
        public String nextLine() {
            tokenizer = new StringTokenizer("");
            return innerNextLine();
        }
        public String next() {
            hasNext();
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

//        public BigInteger nextBigInt() {
//            return new BigInteger(next());
//        }
        // 若需要nextDouble等方法，请自行调用Double.parseDouble包装
    }

}

D. 剪纸游戏

思路: 传统的3种方案

  • DFS
  • BFS
  • 并查集

这边借助BFS实现

通过统计矩形的(minX, minY) -> (maxX, maxY)

然后统计 (maxY - minY + 1) * (maxX - minX + 1) == 连通图的个数

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.StringTokenizer;

public class Main {

    static final int[][] dirs = new int[][] {
            {-1, 0}, {1, 0}, {0, -1}, {0, 1}
    };

    static boolean check(int y, int x, char[][] grid, boolean[][] vis) {
        int h = grid.length, w = grid[0].length;

        int minY = y, minX = x;
        int maxY = y, maxX = x;
        int cnt = 1;

        Deque<int[]> deq = new ArrayDeque<>();
        deq.offer(new int[] {y, x});
        vis[y][x] = true;

        while (!deq.isEmpty()) {
            int[] pos = deq.poll();
            for (int i = 0; i < dirs.length; i++) {
                int ty = pos[0] + dirs[i][0];
                int tx = pos[1] + dirs[i][1];
                if (ty >= 0 && ty < h && tx >= 0 && tx < w) {
                    if (grid[ty][tx] == '.' && !vis[ty][tx]) {
                        vis[ty][tx] = true;
                        deq.offer(new int[] {ty, tx});
                        cnt++;

                        minY = Math.min(minY, ty);
                        minX = Math.min(minX, tx);
                        maxY = Math.max(maxY, ty);
                        maxX = Math.max(maxX, tx);
                    }
                }
            }
        }

        return minY == y && minX == x && (maxX - minX + 1) * (maxY - minY + 1) == cnt;
    }

    public static void main(String[] args) {
        AReader sc = new AReader();

        int h = sc.nextInt(), w = sc.nextInt();
        char[][] grids = new char[h][];
        for (int i = 0; i < h; i++) {
            grids[i] = sc.next().toCharArray();
        }

        int res = 0;
        boolean[][] vis = new boolean[h][w];
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < w; j++) {
                if (grids[i][j] == '.' && !vis[i][j]) {
                    if (check(i, j, grids, vis)) {
                        res++;
                    }
                }
            }
        }
        System.out.println(res);

    }

    static
    class AReader {
        private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        private StringTokenizer tokenizer = new StringTokenizer("");
        private String innerNextLine() {
            try {
                return reader.readLine();
            } catch (IOException ex) {
                return null;
            }
        }
        public boolean hasNext() {
            while (!tokenizer.hasMoreTokens()) {
                String nextLine = innerNextLine();
                if (nextLine == null) {
                    return false;
                }
                tokenizer = new StringTokenizer(nextLine);
            }
            return true;
        }
        public String nextLine() {
            tokenizer = new StringTokenizer("");
            return innerNextLine();
        }
        public String next() {
            hasNext();
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

    }

}

E. 可口蛋糕

思路: 双指针滑窗 + 最大子数组和变体

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) {
        AReader sc = new AReader();

        int n = sc.nextInt();
        long W = sc.nextLong();

        long[] wpre = new long[n + 1];
        long[] ws = new long[n];
        for (int i = 0; i < n; i++) {
            ws[i] = sc.nextInt();
            wpre[i + 1] = wpre[i] + ws[i];
        }

        long[] dpre = new long[n + 1];
        long[] ds = new long[n];
        for (int i = 0; i < n; i++) {
            ds[i] = sc.nextInt();
            dpre[i + 1] = dpre[i] + ds[i];
        }

        long res = Long.MIN_VALUE;
        long best = 0;
        int j = 0;

        for (int i = 0; i < n; i++) {
            while (j <= i && (wpre[i + 1] - wpre[j + 1]) >= W) {
                best = Math.max(best + ds[j], ds[j]);
                best = Math.max(0, best);
                j++;
            }

            if (j > 0) {
                res = Math.max(res, best + dpre[i + 1] - dpre[j]);
            }
        }
        System.out.println(res);
    }

    static
    class AReader {
        private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        private StringTokenizer tokenizer = new StringTokenizer("");
        private String innerNextLine() {
            try {
                return reader.readLine();
            } catch (IOException ex) {
                return null;
            }
        }
        public boolean hasNext() {
            while (!tokenizer.hasMoreTokens()) {
                String nextLine = innerNextLine();
                if (nextLine == null) {
                    return false;
                }
                tokenizer = new StringTokenizer(nextLine);
            }
            return true;
        }
        public String nextLine() {
            tokenizer = new StringTokenizer("");
            return innerNextLine();
        }
        public String next() {
            hasNext();
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }
    }

}

F. 可口蛋糕

思路: lazy线段树 + 珂朵莉树

lazy线段树用于维护 区间更新+点查询

珂朵莉树，则单纯的维护区间

当然这边用差分数组，可以简化lazy线段树(二阶树状数组)

对于区间更新，可以分为l, r+1的分裂和重新组织

这样的话，其分类讨论的情况就变少了。


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class Main {

    public static void main(String[] args) {
        AReader sc = new AReader();

        int n = sc.nextInt(), q = sc.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }

        LazySegTree segTree = new LazySegTree(0, n - 1, arr);

        // 1. 预处理一下
        long acc = 0; // 当前最大的值
        TreeMap<Integer, Integer> tree = new TreeMap<>();
        int j = 0;
        while (j < n) {
            int k = j + 1;
            while (k < n && arr[k - 1] + 1 == arr[k]) {
                k++;
            }
            acc += (long)(k - j) * (k - j);
            tree.put(j, k - 1);
            j = k;
        }

        // 和区间相关的题
        for (int i = 0; i < q; i++) {
            int l = sc.nextInt() - 1, r = sc.nextInt() - 1;
            int d = sc.nextInt();

            if (d == 0) {
                System.out.println(acc);
            } else {
                Map.Entry<Integer, Integer> ent = tree.floorEntry(l);
                segTree.update(l, r, d);
                
                if (ent.getKey() == l) {
                    if (l > 0 && segTree.query(l - 1) + 1 == segTree.query(l)) {
                        Map.Entry<Integer, Integer> ev1 = tree.floorEntry(l - 1);

                        int d1 = ev1.getValue() - ev1.getKey() + 1;
                        int d2 = ent.getValue() - ent.getKey() + 1;
                        acc = acc - (long)d1 * d1 - (long)d2 * d2;
                        acc = acc + (long)(d1 + d2) * (d1 + d2);

                        tree.remove(ev1.getKey());
                        tree.remove(ent.getKey());
                        tree.put(ev1.getKey(), ent.getValue());
                    }
                } else {
                    int d1 = l - ent.getKey();
                    int d2 = ent.getValue() - l + 1;

                    int span = ent.getValue() - ent.getKey() + 1;

                    acc = acc - (long)span * span;
                    acc = acc + (long)d1 * d1 + (long)d2 * d2;

                    tree.remove(ent.getKey());
                    if (ent.getKey() < l) {
                        tree.put(ent.getKey(), l - 1);
                    }
                    tree.put(l, ent.getValue());
                }

                // *)
                Map.Entry<Integer, Integer> ent2 = tree.floorEntry(r);
                if (ent2.getValue() == r) {
                    if (r + 1 < n && segTree.query(r) + 1 == segTree.query(r + 1)) {
                        Map.Entry<Integer, Integer> ev1 = tree.floorEntry(r + 1);

                        int d1 = ent2.getValue() - ent2.getKey() + 1;
                        int d2 = ev1.getValue() - ev1.getKey() + 1;

                        acc = acc - (long)d1 * d1 - (long)d2 * d2;
                        acc = acc + (long)(d1 + d2) * (d1 + d2);

                        tree.remove(ev1.getKey());
                        tree.remove(ent2.getKey());
                        tree.put(ent2.getKey(), ev1.getValue());
                    }
                } else {
                    int d2 = ent2.getValue() - r;
                    int d1 = r - ent2.getKey() + 1;

                    int span = ent2.getValue() - ent2.getKey() + 1;

                    acc = acc - (long)span * span;
                    acc = acc + (long)d1 * d1 + (long)d2 * d2;

                    tree.put(ent2.getKey(), r);
                    if (ent2.getValue() > r) {
                        tree.put(r + 1, ent2.getValue());
                    }
                }
                System.out.println(acc);
            }
        }

    }

    static
    class AReader {
        private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        private StringTokenizer tokenizer = new StringTokenizer("");
        private String innerNextLine() {
            try {
                return reader.readLine();
            } catch (IOException ex) {
                return null;
            }
        }
        public boolean hasNext() {
            while (!tokenizer.hasMoreTokens()) {
                String nextLine = innerNextLine();
                if (nextLine == null) {
                    return false;
                }
                tokenizer = new StringTokenizer(nextLine);
            }
            return true;
        }
        public String nextLine() {
            tokenizer = new StringTokenizer("");
            return innerNextLine();
        }
        public String next() {
            hasNext();
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

//        public BigInteger nextBigInt() {
//            return new BigInteger(next());
//        }
        // 若需要nextDouble等方法，请自行调用Double.parseDouble包装
    }


    static
    public class LazySegTree {

        private int l, r;
        LazySegTree left, right;
        long v;
        long change;

        public LazySegTree(int l, int r, int[] arr) {
            this.l = l;
            this.r = r;
            if (l == r) {
                this.v = arr[l];
            } else {
                int m = l + (r - l) / 2;
                this.left = new LazySegTree(l, m, arr);
                this.right = new LazySegTree(m + 1, r, arr);
            }
        }

        public void update(int ul, int ur, int delta) {
            if (isLeaf()) {
                this.change += delta;
                this.v += this.change;
                this.change = 0;
                return;
            }
            if (this.l >= ul && this.r <= ur) {
                this.change += delta;
                return;
            }
            pushDown();

            int m = l + (r - l) / 2;
            if (ur <= m) {
                this.left.update(ul, ur, delta);
            } else if (ul > m) {
                this.right.update(ul, ur, delta);
            } else {
                this.left.update(ul, m, delta);
                this.right.update(m + 1, ur, delta);
            }
            pushUp();
        }

        public long query(int p) {
            if (isLeaf()) {
                if (this.change != 0) {
                    this.v += this.change;
                    this.change = 0;
                }
                return this.v;
            }
            pushDown();
            int m = l + (r - l) / 2;
            if (p <= m) {
                return this.left.query(p);
            } else {
                return this.right.query(p);
            }
        }

        void pushDown() {
            if (this.change != 0) {
                if (this.left != null) this.left.change += this.change;
                if (this.right != null) this.right.change += this.change;
                this.change = 0;
            }
        }

        void pushUp() {
        }

        boolean isLeaf() {
            return this.l == this.r;
        }

    }

}

写在最后

在这里插入图片描述

珂朵莉酱
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
牛客小白赛实用知识库分享
09-19
例如，在牛客白月赛あなたの蛙は旅っています的题解中，使用动态规划来解决具有最优子结构的问题。 该资源提供了多个牛客白月赛题目的题解和代码实现，涵盖了多个方面的知识领域，可以帮助用户更好地理解和掌握牛客...
python 数据结构 算法 LeetCode 牛客 面试 编程之美 动态规划 字典树 快速排序 树 字符串 数组 链表 全排列
10-08
树 * 字典树 * 遍历-层次遍历 * 遍历-中序遍历-非递归 * 遍历-前序遍历-非递归 * 遍历-后序遍历-非递归 * 二叉查找树-两数之和 * 二叉查找树-中第K小的元素 * 二叉查找树-从有序数组中构造二叉查找树 * 二叉查找树-...
牛客小白月赛86 解题报告 | 珂学家 | 最大子数组和变体 + lazy线段树&amp；动态区间树
2301_79125642的博客
01-20 875
最可恨的是，我没hr微信，准确而言 我自己都不知道自己的对接人是谁！如题，面了个网易外包游戏测试，写的是英语向，然后我在一面的时候问面试官，他说具体是什么项目组后面再确定，不一定是英语的。/** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * * * @param s string字符串 * @return。/** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * * * @param S string字符串 * @param T s。
红球进黑洞【线段树区间更新+二进制异或处理】【牛客小白月赛9-C】
既然弱小，就只顾变强就是了
11-18 244
题目链接   给你N个点，M次查询，问的是（一）、区间【l, r】的数的总和；（二）、把区间【l, r】上的所有点去异或（xor）一个数X。   一开始用了点更新，然后T了，想了一会，最后在比赛结束前终于美滋滋的完成了AC，庆幸，我的想法是这样的，将每个点的值用一个另开的[22]位二进制来存。放心，22位是绝对够的，然后向上更新的是每一位的个数和。这样，就能保证线段树区间更新的速率了。 具体...
牛客小白月赛9 C 红球进黑洞（线段树区间异或+区间求和）
weixin_45688724的博客
01-25 143
原题链接 思路 ： 我们无法得到一个区间更新的公式来做到区间异或，但异或是2进制上的操作，我们可以想到对一个数二进制的每一位来进行操作。因为 10^{5} ，所以二进制位数&lt;20位，因此我们可以开20颗线段树，第 i 颗线段树来维护二进制第 i 位上 1 的个数。 由于0异或上任何数 = 任何数本身，所以如果要异或的 k 的二进制第 i 位上为 0，那么这位就不需要考虑了。 此外，1异或上0=1，1异或上1=0 。也就是说，异或 1 能把 0 变成 1，把 1 变成 0 。所以如果要异或的 k 的二进
牛客 &ndash; 王国(虚树+树的直径)
01-03
题目分析：真的很巧，上周刚学的虚树，读完这个题的第一反应就是可以用虚树简化题目，其实完全可以用树形dp跑一遍dfs出来，可奈何我dp不好，就只能用虚树来做了 题目中有两个点可以单独考虑，首先是权值相同的点，这...
python 数据结构 算法 LeetCode 牛客 面试 编程之美 动态规划 字典树等等
12-27
常见的数据结构包括数组、链表、栈、队列、哈希表、树（如二叉树、AVL树、B树）、图等。在Python中，内置的`list`、`dict`、`set`等都是常用的数据结构，而自定义数据结构则能帮助我们优化特定问题的解决方案。 2. ...
python数据结构算法LeetCode牛客面试编程之美动态规划字母树快速排序树字母串数组链接列表堆排列位运算大数相加_.zip
04-30
这个压缩包&quot;python数据结构算法LeetCode牛客面试编程之美动态规划字母树快速排序树字母串数组链接列表堆排列位运算大数相加_.zip&quot;显然包含了大量与Python编程、数据结构和算法相关的学习资源，特别适合准备面试或...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 859
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 613
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
cf场+线性dp
xxx_jsu的博客
07-23 313
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 157
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
2766. 重新放置石块 Medium
珞米的博客
07-24 497
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 245
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
算法-KMP字符串匹配
xx_xb的博客
07-23 248
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
代码随想录算法训练营第二十二天|回溯算法part01
最新发布
qq_43456971的博客
07-25 580
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
算法题目整合5
qq_62571233的博客
07-23 898
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 296
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
牛客 段错误 数组初值
07-28
1. 数组越界：访问了数组的越界元素。例如，定义了一个长度为5的数组，但是访问了下标为6的元素。 2. 未初始化的指针：访问了一个未初始化的指针，指针没有正确指向有效的内存地址。 3. 内存泄漏：在动态内存分配...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值