[LeetCode 1696] 跳跃游戏 6(Ⅵ)

题面：

数据范围：

1 ≤ n u m s . l e n g t h , k ≤ 1 0 5 1 \le nums.length, \ k \le 10^5 1≤nums.length, k≤105
− 1 0 4 ≤ n u m s [ i ] ≤ 1 0 4 -10^4 \le nums[i] \le 10^4 −104≤nums[i]≤104

思路 & Code

重点： 可以从下标 i i i 跳到 [ i + 1 , m i n ( n − 1 , i + k ) ] [i+1,min(n-1,i+k)] [i+1,min(n−1,i+k)] 区间内的任意一点；得分是所跳到路径的 n u m s nums nums 总和；要求最大得分。

首先自然想到动态规划：设 f [ i ] f[i] f[i] 维护到点 i i i 的最大得分，则 f [ i ] f[i] f[i] 必然是由 j ∈ { 0 , 1 , . . . p ( p < i ) } j\in \{0,1,...p\ (p<i)\} j∈{0,1,...p (p<i)} 中的一个 f [ j ] f[j] f[j] 转移过来的，并且 j + k ≥ i j+k\ge i j+k≥i。直接暴力DP呢，包超的， O ( n 2 ) O(n^2) O(n2)。

但如果只记录前序的最大值 m a x S c o r e maxScore maxScore，却无法判定得到该值的下标 p r e pre pre 是否能够跳到当前点 i i i。

接下来就得想优化策略啦。

1. DP + 最大堆

时间复杂度： O ( n l o g k ) O(nlogk) O(nlogk)
空间复杂度： O ( n ) O(n) O(n)

因为要求最大得分，又是根据前置路径来更新贡献的，所以可以很自然地想到用最大堆 去维护前序最大得分 ，且从下标 0 0 0 开始顺序遍历（保证当前点 i i i 的答案是从前序点过来的）。由于有步长限制 k k k，我们必须判断获得最大得分 的点 p r e pre pre 是否能够跳到当前点 n o w now now，如果其不能跳到，则说明后续所有点的贡献里都不会有 p r e pre pre 点的贡献。

故可以用 p a i r ( m a x S c o r e , i n d e x ) pair(maxScore, index) pair(maxScore,index) 来作为最大堆的元素。

Code：

cpp 复制代码

int maxResult(vector<int>& nums, int k) {
    int n =nums.size();
    priority_queue<pair<int, int>> q; //优先队列维护最大堆
    q.push({nums[0], 0});
    for(int i = 1; i < n; ++i) {
    	//筛选能跳到当前点的最大贡献
        while(!q.empty() && q.top().second < i - k) q.pop();
        //更新最大堆
        q.push({q.top().first + nums[i], i});
    }
    while(!q.empty() && q.top().second != n-1) q.pop();
    return q.top().first;
}

2. DP + 双端队列维护滑动窗口

这就不得不提到非常经典的一道题了 LeetCode 239 滑动窗口最大值

时间复杂度： O ( n ) O(n) O(n)

上面提到只存前序最大值 而没有其下标是不行的。这边可以想到用滑动窗口 去维护 { i − k , i − k + 1 , . . . , i − 1 } \{i-k,i-k+1,...,i-1\} {i−k,i−k+1,...,i−1} 总共 k k k 个 "最大值" 。滑动窗口从队首到队尾的索引依次增大，但是对应的值依次递减，即对于队列 { r 1 , r 2 , . . . , r n } \{r_1, r_2, ..., r_n\} {r1,r2,...,rn}，一定有 d p [ r 1 ] > d p [ r 2 ] > . . . > d p [ r n ] dp[r_1] > dp[r_2] > ... > dp[r_n] dp[r1]>dp[r2]>...>dp[rn]，且 { r 1 < r 2 < r 3 < . . . < r n } \{ r_1 < r_2 < r_3 <... < r_n \} {r1<r2<r3<...<rn}。

遍历时，需要动态维护滑动窗口：

当滑动窗口的左边界（最小下标）已经跳不到当前点了，则直接剔除。
滑动窗口内只保留贡献（最大值）比当前点还大的元素，其他全部剔除。这是由于如果滑动窗口内小于等于当前点贡献的元素，对后续是一定没有贡献的。假设 d p [ j ] ≤ d p [ i ] , j ∈ { i − k , i − k + 1 , . . . , i − 1 } dp[j] \le dp[i]\ ,j \in \{ i-k, i-k+1,...,i-1\} dp[j]≤dp[i] ,j∈{i−k,i−k+1,...,i−1}，首先在滑动窗口向右移动的时候 d p [ j ] dp[j] dp[j] 一定是先被踢出窗口的；其次，当要取到最大值 d p [ i ] = = d p [ j ] dp[i] == dp[j] dp[i]==dp[j] 的时候，由于 i > j i > j i>j， d p [ i ] dp[i] dp[i] 一定是比 d p [ j ] dp[j] dp[j] 能贡献到更后面的下标的（也就是 i i i 跳的比 j j j 远），所以只保留 i i i 即可。
将当前点的贡献和下标一起加入滑动窗口末尾

Code：

cpp 复制代码

int maxResult(vector<int>& nums, int k) {
    int n = nums.size(), maxScore = 0;
    deque<pair<int, int>> dq;
    dq.emplace_back(nums[0], 0);
    maxScore = nums[0];
    for(int i = 1; i < n; ++i) {
        if(dq.front().second < i - k) dq.pop_front();
        maxScore = dq.front().first + nums[i];
        while(!dq.empty() && maxScore >= dq.back().first)
        	dq.pop_back();
        dq.emplace_back(maxScore, i);
    }
    return maxScore;
}