Sponsored
Sponsored
This approach employs dynamic programming in combination with a deque to keep track of the best scores possible when jumping to each index within constraints. By using a decreasing deque, we efficiently maintain the maximum score in a window of size k
.
Time Complexity: O(n), because each element is inserted and removed from the deque at most once. Space Complexity: O(k), to store the window of indices in the deque.
1#include <stdio.h>
2#include <stdlib.h>
3
4// Simple deque implementation
5typedef struct Deque {
6 int front, rear, size;
7 unsigned capacity;
8 int* array;
9} Deque;
10
11Deque* createDeque(unsigned capacity) {
12 Deque* deque = (Deque*)malloc(sizeof(Deque));
13 deque->capacity = capacity;
14 deque->front = deque->size = 0;
15 deque->rear = capacity - 1; // End of the queue
16 deque->array = (int*)malloc(deque->capacity * sizeof(int));
17 return deque;
18}
19
20int isFull(Deque* deque) { return (deque->size == deque->capacity); }
21int isEmpty(Deque* deque) { return (deque->size == 0); }
22void pushBack(Deque* deque, int item) {
23 if (isFull(deque)) return;
24 deque->rear = (deque->rear + 1) % deque->capacity;
25 deque->array[deque->rear] = item;
26 deque->size = deque->size + 1;
27}
28
29void popFront(Deque* deque) {
30 if (isEmpty(deque)) return;
31 deque->front = (deque->front + 1) % deque->capacity;
32 deque->size = deque->size - 1;
33}
34
35int front(Deque* deque) {
36 if (isEmpty(deque)) return -1;
37 return deque->array[deque->front];
38}
39
40int back(Deque* deque) {
41 if (isEmpty(deque)) return -1;
42 return deque->array[deque->rear];
43}
44
45void popBack(Deque* deque) {
46 if (isEmpty(deque)) return;
47 deque->rear = (deque->rear - 1 + deque->capacity) % deque->capacity;
48 deque->size = deque->size - 1;
49}
50
51int maxResult(int* nums, int numsSize, int k) {
52 Deque* dq = createDeque(numsSize);
53 pushBack(dq, 0);
54 for (int i = 1; i < numsSize; i++) {
55 if (front(dq) < i - k) {
56 popFront(dq);
57 }
58 nums[i] += nums[front(dq)];
59 while (!isEmpty(dq) && nums[i] >= nums[back(dq)]) {
60 popBack(dq);
61 }
62 pushBack(dq, i);
63 }
64 int maxScore = nums[numsSize - 1];
65 free(dq->array);
66 free(dq);
67 return maxScore;
68}
In the C implementation, a custom deque is crafted using basic array manipulations to achieve the desired sliding-window maximum score update. This is a lower-level management of memory, leveraging explicit malloc and free allocations.
This approach involves using a dynamic programming solution where we keep track of the best scores using a max-heap (priority queue). By pushing elements onto the heap, we ensure that the maximum score is always accessible, facilitating quick updates for each step in our process.
Time Complexity: O(n log k) due to heap operations. Space Complexity: O(k), maintaining up to k elements in the heap.
1
This JavaScript solution builds a custom max-heap class to maintain the window of scores efficiently, implementing heap methods for insertion and extraction. This ensures the current maximum score is readily available for each step in the process.