⭐算法入门⭐《队列 - 单调队列》中等01 —— LeetCode 1696. 跳跃游戏 VI

最新推荐文章于 2022-06-08 17:35:10 发布

英雄哪里出来

最新推荐文章于 2022-06-08 17:35:10 发布

阅读量4.5k

点赞数 5

分类专栏：《LeetCode算法全集》文章标签：队列算法数据结构动态规划单调队列

本文链接：https://blog.csdn.net/WhereIsHeroFrom/article/details/119771304

版权

《LeetCode算法全集》专栏收录该内容

265 篇文章 1908 订阅

订阅专栏

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

一、题目

1、题目描述

给定一个下标从 0 开始的整数数组nums[]和一个整数 $k$ 。一开始在下标 0 处。每一步，你最多可以往前跳 $k$ 步，但不能跳出数组的边界。也就是说，可以从下标 $i$ 跳到 $[i + 1 ， m i n (n - 1, i + k)]$ 包含两个端点的任意位置。
目标是到达数组最后一个位置（下标为 $n - 1$ ），得分为经过的所有数字之和。请返回能得到的 最大得分。。
样例输入： nums = [1,-1,-2,4,-7,3], k = 2
样例输出： 7

2、基础框架

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

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

3、原题链接

$(1)$ LeetCode 1696. 跳跃游戏 VI

二、解题报告

1、思路分析

比较容易想到的是动态规划，假设跳到位置 $i$ 的最大值是 $d p [i]$ ，可以得到状态转移方程如下： $d p [i] = n u m s [i] + m a x (d p [i - 1], . . ., d p [i - k])$ 但是这一步的问题在于，数组长度为 $n$ 时，状态转移的时间为 $O (k)$ ，所以整個算法的时间复杂度为 $O (n k)$ 。所以我们需要想办法将 $m a x (d p [i - 1], . . ., d p [i - k])$ 这步操作化为 $O (1)$ 。
维护一个单调递减队列，这样就能通过 $O (1)$ 的时间找到从队首找到最大值。单调队列始终保持 $d p [. . .]$ 的元素在队列中是单调递减的。对于队列中的两个元素，下标位置为 $i < j$ , 如果 $\le dp[j]$ ，则 $d p [i]$ 不能放入单调队列中，因为它不会比 $d p [j]$ 更优。并且时刻保证，当前元素插入单调队列之后，单调队列队列首的下标 $x$ ，满足 $\le k$ 。
单调队列是一个双端队列，特点是头部只做删除，尾部可以做插入和删除。

2、时间复杂度

任何一个元素只会在队列中入队和出队最多一次，总的时间复杂度为 $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 dp[maxn];

int maxResult(int* nums, int numsSize, int k){
    int i;
    struct Queue *q = (struct Queue *) malloc (sizeof(struct Queue));
    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) 
        while(!QueueIsEmpty(q) && dp[ QueueGetRear(q) ] <= dp[i])    // (6) 
            QueueDequeueRear(q);
        QueueEnqueue(q, i);                                          // (7) 
    }
    return dp[numsSize-1];
}

$(1)$ 初始化位置；
$(2)$ 初始情况，队列里面只有 0 这个位置；
$(3)$ 从第 1 个位置开始计算 $d p [i]$ ；
$(4)$ 确保计算过程中的区间范围在 $[i - 1, i - k]$ 范围内；
$(5)$ 利用单调队列性质，dp[ QueueGetFront(q) ]必然最大，直接赋值；
$(6)$ $d p [i]$ 一定会插入单调队列，所以比它小的都应该出队；
$(7)$ 执行插入操作；

三、本题小知识

某些问题初始思路都是动态规划，无论能否用动态规划在规定时间范围内求解，都可以先用状态转移方程把它写出来。有的状态转移方程，再去看哪一步需要优化，从而考虑用什么数据结构进行优化。

四、加群须知

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

🌌《算法入门指引》🌌
如果链接被屏蔽，或者有权限问题，可以私聊作者解决。

大致题集一览：

在这里插入图片描述

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

🔥让天下没有难学的算法🔥
C语言免费动漫教程，和我一起打卡！ 🌞《光天化日学C语言》🌞
入门级C语言真题汇总 🧡《C语言入门100例》🧡
几张动图学会一种数据结构 🌳《画解数据结构》🌳
组团学习，抱团生长 🌌《算法入门指引》🌌
竞赛选手金典图文教程 💜《夜深人静写算法》💜