⭐算法入门⭐《队列 - 单调队列》中等03 —— LeetCode 918. 环形子数组的最大和

Posted 英雄哪里出来

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了⭐算法入门⭐《队列 - 单调队列》中等03 —— LeetCode 918. 环形子数组的最大和相关的知识,希望对你有一定的参考价值。

一、题目

1、题目描述

  给定一个由整数数组 A 表示的 环形数组 C,求 C 的非空子数组的最大可能和。
  在此处,环形数组意味着数组的末端将会与开头相连呈环状。(形式上,当 0 ≤ i < A . l e n g t h 0 \\le i \\lt A.length 0i<A.length C [ i ] = A [ i ] C[i] = A[i] C[i]=A[i],且当 i ≥ 0 i \\ge 0 i0 C [ i + A . l e n g t h ] = C [ i ] C[i+A.length] = C[i] C[i+A.length]=C[i]);
  此外,子数组最多只能包含固定缓冲区 A 中的每个元素一次。
  样例输入: [1,-2,3,-2]
  样例输出: 3

2、基础框架

  • C语言 版本给出的基础框架代码如下:
int maxSubarraySumCircular(int* nums, int numsSize){
}

3、原题链接

LeetCode 918. 环形子数组的最大和

二、解题报告

1、思路分析

  1)如果所有的数都是负数,那么一定是找最大的那个数作为答案返回;
  2)否则,我们将原数组拷贝一份等长的数据到原数组的后面,问题就转变成了求:长度不超过 n n n 的最大和子数组;
  3)令 s u m [ i ] sum[i] sum[i] 代表 C [ i ] C[i] C[i] 的前缀和,对于一段左开右闭子数组 ( t , i ] (t, i] (t,i] s u m [ i ] − s u m [ t ] sum[i] - sum[t] sum[i]sum[t] 就是这段子数组的和,其中 − 1 ≤ t < i -1 \\le t < i 1t<i,并且必须满足数组长度 i − t ≤ n i - t \\le n itn
  4)对于两个下标 t 1 < t 2 t_1 \\lt t_2 t1<t2, 如果 s u m [ t 1 ] ≥ s u m [ t 2 ] sum[t_1] \\ge sum[t_2] sum[t1]sum[t2],则 s u m [ t 1 ] sum[t_1] sum[t1] 不会比 s u m [ t 2 ] sum[t_2] sum[t2] 更优,所以,我们只需要维护一个 s u m sum sum 值单调递增的单调队列,单调队列的队首一定是 s u m sum sum 值最小的,所以队首的元素作为候选 t t t 一定是最合适的;
  5)然后只需要枚举 i i i,维护 s u m [ i ] sum[i] sum[i] 的单调队列,且单调队列插入的是前缀和的下标值,候选最优值 s u m [ i ] − s u m [ q u e u e f r o n t ] sum[i] - sum[ queuefront ] sum[i]sum[queuefront] 用于和最终最优值进行比较取大者,保证单调队列的队尾 和 队首 差值大于等于 n n n,不满足时,不断弹出队首;

2、时间复杂度

   单调队列进出是 O ( n ) O(n) O(n),枚举下标的过程和单调队列的进出无关,也是 O ( n ) O(n) O(n)。所以,总的时间复杂度为 O ( n ) O(n) O(n)

3、代码详解


/**************************** 顺序表 实现双端队列 ****************************/
#define DataType int
#define maxn 100005

struct Queue {
    DataType data[maxn];
    int head, tail;
};

void QueueClear(struct Queue* que) {
    que->head = que->tail = 0;
}
void QueueEnqueue(struct Queue *que, DataType dt) {
    que->data[ que->tail++ ] = dt;
}
void QueueDequeueFront(struct Queue* que) {
    ++que->head;
}
void QueueDequeueRear(struct Queue* que) {
    --que->tail;
}

DataType QueueGetFront(struct Queue* que) {
    return que->data[ que->head ];
}
DataType QueueGetRear(struct Queue* que) {
    return que->data[ que->tail - 1 ];
}
int QueueGetSize(struct Queue* que) {
    return que->tail - que->head;
}
int QueueIsEmpty(struct Queue* que) {
    return !QueueGetSize(que);
}

/**************************** 顺序表 实现双端队列 ****************************/

int sum[maxn];
struct Queue q;

int getValue(int index) {
    if(index == -1) {
        return 0;
    }
    return sum[index];
}

int maxSubarraySumCircular(int* nums, int numsSize){
    int i;
    int ans, val;
    int *a = (int *)malloc( 2 * numsSize * sizeof(int) );
    int maxv = -10000000000;

    for(i = 0; i < numsSize; ++i) {
        if(nums[i] > maxv) {
            maxv = nums[i];           
        }
    }
    if(maxv <= 0) {
        return maxv;                    // (1)
    }

    for(i = 0; i < numsSize; ++i) {
        a[i] = a[i+numsSize] = nums[i]; // (2)
    }

    for(i = 0; i < numsSize*2; ++i) {   // (3)
        sum[i] = a[i];
        if(i)
            sum[i] += sum[i-1];
    }
    QueueClear( &q );
    QueueEnqueue(&q, -1);                // (4)

    ans = -2000000000;
    for(i = 0; i < numsSize*2; ++i) {
        while(!QueueIsEmpty(&q) && getValue( QueueGetRear(&q) ) >= getValue(i)) 
            QueueDequeueRear(&q);       // (5)
        while(!QueueIsEmpty(&q) && i - QueueGetFront(&q) > numsSize)
            QueueDequeueFront(&q);      // (6)
        QueueEnqueue(&q, i);            // (7)
        val = getValue( QueueGetRear(&q) ) - getValue( QueueGetFront(&q) );
        if( val > ans )
            ans = val;
    }
    return ans;
}

  • ( 1 ) (1) (1) 如果最大值都是小于等于零的,则直接返回最大值;
  • ( 2 ) (2) (2) 拷贝一份,作为环形
  • ( 3 ) (3) (3) 计算前缀和
  • ( 4 ) (4) (4) 单调队列初始情况塞入一个 − 1 -1 1,代表了 s u m [ − 1 ] sum[-1] sum[1] ,值为 0;
  • ( 5 ) (5) (5) 确保这是单调递增的队列;
  • ( 6 ) (6) (6) 控制队列长度不超过numsSize;
  • ( 7 ) (7) (7) 下标 i i i 必然是一个可行解,需要入队;

三、本题小知识

单调队列在执行的时候,和外层枚举是分别计算时间复杂度的,所以时间复杂度是加法关系。


四、加群须知

  相信看我文章的大多数都是「 大学生 」,能上大学的都是「 精英 」,那么我们自然要「 精益求精 」,如果你还是「 大一 」,那么太好了,你拥有大把时间,当然你可以选择「 刷剧 」,然而,「 学好算法 」,三年后的你自然「 不能同日而语 」
  那么这里,我整理了「 几十个基础算法 」 的分类,点击开启:

🌌《算法入门指引》🌌

  如果链接被屏蔽,或者有权限问题,可以私聊作者解决。

  大致题集一览:





  为了让这件事情变得有趣,以及「 照顾初学者 」,目前题目只开放最简单的算法 「 枚举系列 」 (包括:线性枚举、双指针、前缀和、二分枚举、三分枚举),当有 一半成员刷完 「 枚举系列 」 的所有题以后,会开放下个章节,等这套题全部刷完,你还在群里,那么你就会成为「 夜深人静写算法 」专家团 的一员。
  不要小看这个专家团,三年之后,你将会是别人 望尘莫及 的存在。如果要加入,可以联系我,考虑到大家都是学生, 没有「 主要经济来源 」,在你成为神的路上,「 不会索取任何 」
  🔥联系作者,或者扫作者主页二维码加群,加入刷题行列吧🔥


🔥让天下没有难学的算法🔥

C语言免费动漫教程,和我一起打卡!
🌞《光天化日学C语言》🌞

入门级C语言真题汇总
🧡《C语言入门100例》🧡

几张动图学会一种数据结构
🌳《画解数据结构》🌳

组团学习,抱团生长
🌌《算法入门指引》🌌

竞赛选手金典图文教程
💜《夜深人静写算法》💜

以上是关于⭐算法入门⭐《队列 - 单调队列》中等03 —— LeetCode 918. 环形子数组的最大和的主要内容,如果未能解决你的问题,请参考以下文章

⭐算法入门⭐《队列 - 单调队列》中等04 —— LeetCode 剑指 Offer 59 - II. 队列的最大值

⭐算法入门⭐《队列 - 单调队列》中等02 —— LeetCode 1438. 绝对差不超过限制的最长连续子数组

⭐算法入门⭐《队列 - 单调队列》困难03 —— LeetCode 862. 和至少为 K 的最短子数组

⭐算法入门⭐《队列 - 单调队列》困难01 —— LeetCode 239. 滑动窗口最大值

⭐算法入门⭐《队列 - 单调队列》困难02 —— LeetCode1425. 带限制的子序列和

单调队列——从入门到入门