> For the complete documentation index, see [llms.txt](https://mayanktyagi3111.gitbook.io/interview-prep/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mayanktyagi3111.gitbook.io/interview-prep/dynamic-programming/constrained-subsequence-sum.md).

# Constrained Subsequence Sum

Given an integer array `nums` and an integer `k`, return the maximum sum of a **non-empty** subsequence of that array such that for every two **consecutive** integers in the subsequence, `nums[i]` and `nums[j]`, where `i < j`, the condition `j - i <= k` is satisfied.

A *subsequence* of an array is obtained by deleting some number of elements (can be zero) from the array, leaving the remaining elements in their original order.

**Example 1:**

```
Input: nums = [10,2,-10,5,20], k = 2
Output: 37
Explanation: The subsequence is [10, 2, 5, 20].
```

**Example 2:**

```
Input: nums = [-1,-2,-3], k = 1
Output: -1
Explanation: The subsequence must be non-empty, so we choose the largest number.
```

**Example 3:**

```
Input: nums = [10,-2,-10,-5,20], k = 2
Output: 23
Explanation: The subsequence is [10, -2, -5, 20].
```

**Constraints:**

* `1 <= k <= nums.length <= 10^5`
* `-10^4 <= nums[i] <= 10^4`

```java
class Solution {
    public int constrainedSubsetSum(int[] nums, int k) {
        // This deque is going to be a strictly increasing deque(right -> left)
        Deque<Integer> deque = new LinkedList<>();
        int n = nums.length;
        int[] dp = new int[n];
        // dp[i] is the maximum sum we can get from nums[:i] and nums[i] is guaranteed
        // to be included.
        int res = Integer.MIN_VALUE;

        for (int i = 0; i < n; i++) {
            // Kicking out the values out of index window -> k
            while (!deque.isEmpty() && i - deque.peekFirst() > k)
                deque.pollFirst();
            // The max value is on top of deque
            dp[i] = Math.max(nums[i], (deque.isEmpty() ? 0 : dp[deque.peekFirst()]) + nums[i]);
            // Maintaining increasing deque
            while (!deque.isEmpty() && dp[i] > dp[deque.peekLast()])
                deque.pollLast();
            // Adding to the last
            deque.addLast(i);
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}
```