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

Posted 2021-09-06 英雄哪里出来

🙉饭不食，水不饮，题必须刷🙉
C语言免费动漫教程，和我一起打卡！ 🌞《光天化日学C语言》🌞
LeetCode 太难？先看简单题！ 🧡《C语言入门100例》🧡
数据结构难？不存在的！ 🌳《画解数据结构》🌳
LeetCode 太简单？算法学起来！ 🌌《夜深人静写算法》🌌

文章目录

• 一、题目
• • 1、题目描述
  • 2、基础框架
  • 3、原题链接
• 二、解题报告
• • 1、思路分析
  • 2、时间复杂度
  • 3、代码详解
• 三、本题小知识

一、题目

1、题目描述

  给定一个整数数组nums和一个整数$k$ ，请返回 非空 子序列元素和的最大值，子序列需要满足：子序列中每两个 相邻 的整数 nums[i]和 nums[j]，它们在原数组中的下标 $i$ 和 $j$ 满足 $i<j$ 且 $j-i\le k$。
  数组的子序列定义为：将数组中的若干个数字删除（可以删除 0 个数字），剩下的数字按照原本的顺序排布。
  样例输入： nums = [10,2,-10,5,20], k = 2
  样例输出： 37

2、基础框架

• C语言版本 给出的基础框架代码如下：

int constrainedSubsetSum(int* nums, int numsSize, int k){
}

3、原题链接

$(1)$ LeetCode 1425. 带限制的子序列和

二、解题报告

1、思路分析

  首先，容易想到状态转移方程
$$dp[i]=nums[i]+\underset{j=i-k}{\overset{i-1}{\max }}dp[j]$$ 这是一个时间复杂度为 $O(nk)$ 的算法；
  我们考虑 ${\max }_{j=i-k}^{i-1}dp[j]$ 这一段，如果能够通过 $O(1)$ 的时间复杂度来获取，这样总的时间复杂度就变成了 $O(n)$，这个式子展开后得到 $max(dp[i-k],dp[i-k+1],...,dp[i-1])$ ，于是，我们可以维护一个 $(dp[i-k],dp[i-k+1],...,dp[i-1])$ 的队列；
  问题转化成求这个队列中的最大值，由于队列只支持取队列头操作，所以队列头的必然是最大值，即这是一个单调递减的队列。加入队列中的两个元素 $i<j$ 且 $dp[i]\le dp[j]$，那么 $dp[i]$ 不会比 $dp[j]$ 更优，直接舍弃即可，所以整个队列中的元素一定满足 $i<j$ 时，$dp[i]>dp[j]$，即它是一个 单调递减队列；
  迭代计算 $dp[i]$ 的值即可。 取 ${\max }_{i=0}^{n-1}dp[i]$ 就是最后的答案了。

2、时间复杂度

• 任何一个元素只会 入队 和 出队 各一次，总的时间复杂度为 $O(n)$。均摊下来每次的操作就是 $O(1)$ 的。

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 dp[maxn];

int constrainedSubsetSum(int* nums, int numsSize, int k){
    struct Queue *q = (struct Queue *)malloc( sizeof(struct Queue) );
    int i, max;
    max = dp[0] = nums[0];                                           // (1) 
    QueueClear(q);
    QueueEnqueue(q, 0);                                              // (2) 
    for(i = 1; i < numsSize; ++i) {                                  // (3) 
        while(!QueueIsEmpty(q) && i - QueueGetFront(q) > k)          // (4) 
            QueueDequeueFront(q);
        dp[i] = nums[i] + dp[ QueueGetFront(q) ];                    // (5) 
        if (dp[ QueueGetFront(q) ] < 0) 
            dp[i] =  nums[i];                                        // (6) 
        while(!QueueIsEmpty(q) && dp[ QueueGetRear(q) ] <= dp[i])    // (7) 
            QueueDequeueRear(q);
        QueueEnqueue(q, i);                                          // (8) 
        if(dp[i] > max)
            max = dp[i];                                             // (9) 
    }
    return max;
}

• $(1)$ 初始化第 0 个元素的值；
• $(2)$ 将第 0 个元素的位置 插入队列；
• $(3)$ 从第 1 个元素开始迭代计算 $dp[i]$；
• $(4)$ 确保相邻两个元素的差值 $\le k$；
• $(5)$ $O(1)$ 计算 $dp[i]$；
• $(6)$ 如果前面的都 小于 0，那么从第 $i$ 个数开始肯定更优；
• $(7)$ 确保队列单调递减；
• $(8)$ 将当前元素插入队列；
• $(9)$ 注意，这里需要遍历 $dp[i]$ 统计最大值；

---

三、本题小知识

   一般用单调队列来优化动态规划的问题中，都会涉及两次出队操作
    $(1)$ 确保区间范围合法；
    $(2)$ 确保队列的单调性；

---