子数组和 问题汇总

子数组和问题汇总及解法
最新推荐文章于 2025-12-02 23:24:25 发布
原创 最新推荐文章于 2025-12-02 23:24:25 发布 · 720 阅读 · 11 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#leetcode #c++

文章目录

  • 子数组：也就是在原来的数组当中连续的元素，那么对应的解题方法也是有套路的：
    • 常用思路：使用前缀和+贪心、动态规划（例如，dp[i]为以nums[i]结尾的最值情况）
    • 限制子数组的长度：使用窗口
    • 窗口内最值：使用单调队列

买卖股票的最佳时机

买卖股票的最佳时机
在这里插入图片描述

  • 思路分析：
    • 贪心：最大的利益收益，那么对于某一天i来说，我们只需在它前面的那么多天当中，价格最低的哪一天买入，也就是维护一个变量leftmin ，我们就可以计算出当天i卖出的可以赚到的最优情况，将nums[i] - leftmin与我们的答案ans进行比较，然后进行更新（插播一句，所谓的优化，也只是优化这个遍历的情况的时间复杂度，减少无效多余的情况）
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        // 贪心问题
        int n = prices.size(),leftmin = prices[0],ans = 0;
        for (int i = 1;i < n; i++){
            int tmp = prices[i] - leftmin;
            ans = tmp > ans ? tmp : ans;
            leftmin = min(leftmin,prices[i]);
        }
        return ans;
    }
};

最大子数组和

在这里插入图片描述

  • 思路分析：
    • 前缀和+贪心： 涉及到子数组和的问题，当我们求解出nums数组的前缀和的时候，就可以转化为上面的买卖股票的最佳时机的问题
    • 动态规划：我们规定dp[i]为以nums[i]结尾的最大子数组的和，就有递推公式dp[i] = max(dp[i-1]+nums[i]，nums[i])

前缀和+贪心：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        // 最大子数组和 
        // 涉及到这个的都一般使用前缀和，然后使用贪心的买卖股票的思路
        int n = nums.size();
        vector<int> pre(n+1);
        for (int i = 0; i < n; i++){
            pre[i+1] = pre[i] + nums[i];
        }
        // 开始贪心
        int leftmin = 0,ans = -0x3f3f3f3f;
        for (int i = 0;i < n;i++){
            ans = max(ans,pre[i+1] - leftmin);
            leftmin = min(leftmin,pre[i+1]);
        }
        return ans;
        
    }
};

动态规划：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        // 最大子数组和 
        // 使用动态规划
        // dp[i]为以nums[i]结尾的最大子数组和
        int n = nums.size();
        vector<int> dp(n);
        dp[0] = nums[0];
        int ans = dp[0];
        for (int i = 1; i < n; i++){
            dp[i] = max(nums[i],dp[i-1] + nums[i]);
            ans = max(ans,dp[i]);

        }
        return ans;
    }
};

拓展

如果求解的是需要返回具体的数组（或者下标）

  • 思路分析：对于这种需要返回具体的数组的情况，当然得使用left、right、ansleft、ansright4个变量进行分别记录 当前情况的子数组的两端和最右情况的两端
  • 更新策略：（使用动态规划思路）：当dp[i-1] + nums[i] > nums[i]的时候，有更新right = i，不用更新这个left；否则就是更新left = i，right = i。当最终的dp[i]>ans的时候，我们才有更新ansleft = left，ansright = right
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        // 如果需要返回这个子数组，那其实只要记录这个子数组的两个端点即可
        int n = nums.size(),left = 0,right = 0,ansleft = 0,ansright = 0;
        // 使用动态规划求解
        vector<int> dp(n);
        dp[0] = nums[0];
        int ans = dp[0];
        for (int i = 1;i < n ;i++){
            if (dp[i-1] + nums[i] > nums[i]){
                right = i;
            }else{
                left = i;
                right = i;
            }
            dp[i] = max(dp[i-1] + nums[i],nums[i]);

            if (dp[i] > ans){
                ansleft = left;
                ansright = right;
            }
            ans = max(ans,dp[i]);
            
        }
        cout << ansleft << " " << ansright ;
        return ans;

    }
};

如果子数组长度有下界

  • 题目要求：求解原数组当中，子数组的和的最大值，要求子数组的长度必须>=k

  • 思路分析：

    • 滑动窗口：对于长度的限制，就是要设置一个窗口来实现，但是对于窗口内的最小值的选取，就需要使用到这个单调队列，优先队列的话，我们在加入新元素的时候，会把队列当中比它大的元素全部出队列，最终就可以实现，队列的元素是逐渐递增的，q.front是窗口最小的元素
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        // 如果求解的是有下界的最大子数组和的问题
        int n = nums.size();
        vector<int> pre(n+1);
        for (int i = 0;i < n;i++){
            pre[i+1] = pre[i] + nums[i];
        }
        int ans = -0x3f3f3f3f,leftmin = 0;
        // 使用优先队列，保持一个递增的队列
        deque<int>  q;
        for (int i = k; i <= n;i++){
            int left = i - k;

            // 将左端点放进去
            while ( !q.empty() && pre[q.back()] > pre[left]){
                q.pop_back();
            }
            q.push_back(left);
            
            // 更新答案
            if (!q.empty()){
                ans = max(ans, pre[i] - pre[q.front()]);
            }

        }
        return ans;

    }
};

如果子数组长度存在上界

  • 问题要求：求解原数组当中，求解最大子数组和，并且要求子数组的长度必须<=k

  • 思路分析：

    • 确保窗口的最大值<=k：我们对于这个单调队列q.front<left就弹出（队列当中的值存储的是下标，并且下标是递增的）即可，就是在这个下界 基础上，增加了对这个队列首部元素的判断
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        // 如果求解的是有上界的最大子数组和的问题
        int n = nums.size();
        vector<int> pre(n+1);
        for (int i = 0;i < n;i++){
            pre[i+1] = pre[i] + nums[i];
        }
        int ans = -0x3f3f3f3f,leftmin = 0;
        // 使用优先队列，保持一个递增的队列
        deque<int>  q;
        for (int i = k; i <= n;i++){
            int left = i - k;

            while (!q.empty() && q.front < left){
                q.pop_front();
            }
            
            // 将左端点放进去
            while ( !q.empty() && pre[q.back()] > pre[left]){
                q.pop_back();
            }
            q.push_back(left);
            
            // 更新答案
            if (!q.empty()){
                ans = max(ans, pre[i] - pre[q.front()]);
            }

        }
        return ans;

    }
};

子数组的长度固定求解窗口最大值

滑动窗口最大值
在这里插入图片描述

  • 思路分析：
    • 固定长度的区别：由于要保持这个单调性问题，所以在队列的末尾增加这个元素的时候，使用的是while也就是不满足的元素都会出队列，但是由于要保证这个子数组的长度是k，所以每次出队列只用出一个元素，所以使用的是if
class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> ans;
        int n = nums.size();
        // 使用一个双端队列来实现，保证每一个元素只进来一次
        deque<int> q;
        for (int i = 0; i < n;i++){
            // 右边进入
            while (!q.empty() && nums[q.back()] <= nums[i]){
                q.pop_back();
            }

            q.push_back(i);
            
            // 左边出
            int left = i - k + 1;
            if (q.front() < left){
                q.pop_front();
            }

            // 在窗口左端点记录答案
            if (left >=0 ){
                ans.push_back(nums[q.front()]);
            }
            
        }
        return ans;
    }
};

长度小总结

  • 一般思路：出队列，入队列，更新
  • 细节区别：入队列是必须的，出队列不一定（子数组有下界要求不用出队列）；出队列的次数不一定（固定长度每次出一个即可）

子数组的长度必须是奇数

  • 题目要求：要求求解的子数组的最大和的同时这个子数组的长度必须是奇数
  • 思路分析：由于要求长度必须是奇数，也就是需要记录奇数和偶数的情况，所以我们采用动态规划的思想：
    • dp0[i]表示以nums[i]结尾的偶数长度的子数组的最大和
    • dp1[i]表示以nums[i]结尾的奇数长度的子数组的最大和
    • 递推公式dp0[i] = dp1[i-1] + nums[i]和dp1[i] = max(dp0[i-1] + nums[i]，nums[i])
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        // 如果求解的是长度必须是奇数的最大子数组和的问题
        int n = nums.size();
        // 使用动态规划
        // dp0[i]表示以nums[i]结尾长度为偶数的最大子数组和
        // dp1[i]表示以nums[i]结尾长度为奇数的最大子数组和
        vector<int> dp0(n),dp1(n);
        dp0[0] = -0x3f3f3f3f;
        dp1[0] = nums[0];
        int ans = dp1[0];
        for (int i = 1;i < n;i++){
            dp0[i] = dp1[i-1] + nums[i];
            dp1[i] = max(dp0[i-1] + nums[i],nums[i]);
            ans = max(ans,dp1[i]);
        }
        return ans;

    }
};
【华为OD机试】真题A卷-等和子数组最小和（JAVA）
u014481728的博客
03-19 590
【华为OD机试】真题A卷-等和子数组最小和（JAVA）：给定一个数组nums,将元素分为若干个组，使得每组和相等，求出满足条件的所有分组中，组内元素和的最小值。
【华为OD机考真题】- 几何平均值最大子数组（Java）
**My Coding Family**
03-06 1285
🔔本文收录于「2025华为OD机试真题(Java版)」专栏，手把手带你零基础教学华为OD机试。本题集提供最优题解思路，解题步骤，代码解析，复杂度分析及最优题解源码等，支持多语言题解，助你轻松拿捏OD机考，一举上岸！安利大家关注&&收藏&&订阅！题库正在疯狂收录中，up！up！up！！ 🚫提醒：拒绝一切代考/替考，违法必究！    💗订阅福利：一次订阅，可永久免费阅读，提供在线答疑解惑，后续题库更新皆可阅读使用！
数组累加和——汇总
Go的全部
11-13 2334
数组累加和问题三连
LeetCode 2104. 子数组范围和
英雄哪里出来
03-30 825
线性枚举
动态规划：8行代码搞定最大子数组和问题
<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd
03-23 277
????????关注后回复“进群”，拉你进程序员交流群????????作者丨小风哥来源丨码农的荒岛求生（ID：escape-it）今天给大家带来一道极其经典的题目，叫做最大和子数组，给定一个数组，找到其中的一个连续子数组，其和最大。示例：输入:nums=[-2,1,-3,4,-1,2,1,-5,4] 输出:6 解释:子数组[4,-1,2,1]的和为6，其它任何连续的子数组和不超过6...
java 取子数组_Java获取子数组的最大和算法
weixin_42220669的博客
02-13 495
题目：输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。求所有子数组的和的最大值。要求时间复杂度为O(n)。例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，因此输出为该子数组的和18。解决思路：如果前几项数值累加的结果为负，则可以将这几项排除，因为负数累加后肯定会使总值减少。...
【C++单调队列 前缀和】862. 和至少为 K 的最短子数组|2306
闻缺陷则喜何志丹
10-30 738
给你一个整数数组 nums 和一个整数 k ，找出 nums 中和至少为 k 的 最短非空子数组 ，并返回该子数组的长度。如果不存在这样的 子数组 ，返回 -1 。 子数组 是数组中 连续 的一部分。
LeetCode动态规划经典题目（九）：子序列、子数组问题
m0_60750183的博客
02-24 546
LeetCode动态规划经典题目（九）：子序列、子数组问题
​LeetCode刷题实战560：和为 K 的子数组
程序IT圈
03-22 255
算法的重要性，我就不多说了吧，想去大厂，就必须要经过基础知识和业务逻辑面试+算法面试。所以，为了提高大家的算法能力，这个公众号后续每天带大家做一道算法题，题目就从LeetCode上面选 ！今天和大家聊的问题叫做和为 K 的子数组，我们先来看题面：https://leetcode-cn.com/problems/subarray-sum-equals-k/Givenan...
Java实现求子数组和的最大值算法示例
08-28
要实现求子数组和的最大值算法，需要遍历数组，计算每个子数组的和，并记录最大和的子数组。下面是Java实现的示例代码： ```java public class MaxSub { public static void main(String[] args) { ...
【华为OD机试真题 Java语言】142、等和子数组最小和 | 机试真题+思路参考+代码解析（多用例）
KJ.JK
08-21 1125
给定一个数组nums，将元素分为若干个组，使得每组和相等，求出满足条件的所有分组中，组内元素和的最小值
【华为OD机试】真题A卷-等和子数组最小和（Python）
u014481728的博客
03-19 576
【华为OD机试】真题A卷-等和子数组最小和（Python）：给定一个数组nums,将元素分为若干个组，使得每组和相等，求出满足条件的所有分组中，组内元素和的最小值。
力扣1971.寻找图中是否存在路径
2401_89332662的博客
11-30 695
本文研究了无向图中顶点连通性判断问题，针对大规模数据（顶点数达2×10^5）提出两种高效解法。并查集方法通过路径压缩和按秩合并优化，实现接近线性的时间复杂度；BFS方法通过邻接表存储和队列遍历确保高效性。实验表明两种方法均能有效处理大规模图数据，其中并查集在空间效率上更具优势。文章详细阐述了两种算法的实现细节，包括数据结构设计、核心操作流程和复杂度分析，为大规模图连通性问题提供了实用解决方案。
Leetcode 65 固定长度窗口 | 中心辐射型固定窗口
im_AMBER的博客
12-01 820
窗口是 “连续固定长度” 还是 “以某个点为中心辐射”？若题目说 “长度为 k 的子数组”→ 普通固定窗口；若题目说 “半径为 k”“以每个元素为中心”→ 中心辐射型窗口。结果是 “每个窗口对应一个值” 还是 “每个索引对应一个值”？前者→普通固定窗口；后者→中心辐射型窗口。
LeetCode面试HOT100—— 206. 反转链表
xwhxy的博客
12-02 630
本文详细解析了反转单链表的迭代最优解（头插法）。该方法通过三个指针（pre、cur、nxt）实现，时间复杂度O(n)，空间复杂度O(1)。核心思路是将原链表节点逐个取出并插入新链表头部，最终返回pre指针指向的新链表头。文章通过逐行代码注释、分步演示（1→2→3→4→null示例）和关键细节分析，帮助读者彻底理解反转过程。特别强调了保存nxt指针的必要性和边界情况处理，总结为"保存下一个，反转当前，移动双指针"的操作口诀。
LeetCode 热题 100——二叉树——二叉树的层序遍历&将有序数组转换为二叉搜索树
weixin_53318497的博客
12-02 547
给你二叉树的根节点 root ，返回其节点值的 层序遍历。（即逐层地，从左到右访问所有节点）。示例 1：输入：root = [3,9,20,null,null,15,7]输出：[[3],[9,20],[15,7]]示例 2：输入：root = [1]输出：[[1]]示例 3：输入：root = []输出：[]提示：树中节点数目在范围 [0, 2000] 内。
LeetCode 230：二叉搜索树中第 K 小的元素 —— 从 Inorder 遍历到 Order Statistic Tree
六六哥的博客
12-02 746
preorder（根–左–右）得到的序列一般不是有序的，所以用 preorder 数到的第 k 个节点并不等于第 k 小的节点。Follow-up 问的是更偏「数据结构设计」的问题：如果这棵 BST 经常执行插入、删除，并且频繁查询第 k 小，用每次 inorder 从头数的方式就不够高效了，因为每次查询仍然可能接近 O(n)。利用 inorder 的有序性，一个直接的解法是：递归做 inorder 遍历，同时维护一个外部计数器 count，当访问到第 k 个节点时记录答案并提前结束遍历。
LeetCode算法刷题——560. 和为 K 的子数组
2301_76925430的博客
12-01 643
本文介绍了使用前缀和和哈希表统计和为k的子数组个数的高效算法。该算法的核心在于将问题转化为寻找两个前缀和之差等于k的情况。通过维护一个哈希表记录每个前缀和出现的次数，我们可以在O(n)时间复杂度内解决问题。这种方法特别适用于包含负数的数组，而滑动窗口法只适用于全正数的情况。关键点包括：正确初始化mp[0]=1、理解sum-k的含义、以及及时更新前缀和的出现次数。
LeetCode 439 - 三元表达式解析器
最新发布
网罗天下方法，方便你我开发！！！
12-02 364
题目给出一个嵌套的三元表达式（条件 ? expr1 : expr2），条件仅为字符 'T' 或 'F'，表达式中的值为单字符（比如 '0'..'9'、字母或另一个三元表达式）。任务是解析该字符串，返回最终的值（仍为单字符）。 这道题看上去像是写一个小解析器，但用一个简单的栈 + 从右向左扫描技巧，就能优雅地解决所有嵌套情况，代码短、易理解。
Swift 数组 汇总添加子数组
07-05
如果希望将子数组的内容添加到现有数组末尾，可以使用 `append(contentsOf:)` 方法[^2]。该方法不会创建新的数组，而是直接修改原数组： ```swift var mainArray = [1, 2, 3] let subArray = [4, 5, 6] mainArray....
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值