feat: add solutions to lc problem: No.1696 (doocs#2296)

No.1696.Jump Game VI

Author: yanglbme

solution/1600-1699/1696.Jump Game VI/README.md

@@ -113,9 +113,13 @@ public:
         f[0] = 0;
         deque<int> q = {0};
         for (int i = 0; i < n; ++i) {
-            if (i - q.front() > k) q.pop_front();
+            if (i - q.front() > k) {
+                q.pop_front();
+            }
             f[i] = nums[i] + f[q.front()];
-            while (!q.empty() && f[q.back()] <= f[i]) q.pop_back();
+            while (!q.empty() && f[i] >= f[q.back()]) {
+                q.pop_back();
+            }
             q.push_back(i);
         }
         return f[n - 1];
@@ -127,19 +131,193 @@ public:
 func maxResult(nums []int, k int) int {
 	n := len(nums)
 	f := make([]int, n)
-	q := []int{0}
-	for i, v := range nums {
-		if i-q[0] > k {
-			q = q[1:]
+	q := Deque{}
+	q.PushBack(0)
+	for i := 0; i < n; i++ {
+		if i-q.Front() > k {
+			q.PopFront()
 		}
-		f[i] = v + f[q[0]]
-		for len(q) > 0 && f[q[len(q)-1]] <= f[i] {
-			q = q[:len(q)-1]
+		f[i] = nums[i] + f[q.Front()]
+		for !q.Empty() && f[i] >= f[q.Back()] {
+			q.PopBack()
 		}
-		q = append(q, i)
+		q.PushBack(i)
 	}
 	return f[n-1]
 }
+
+type Deque struct{ l, r []int }
+
+func (q Deque) Empty() bool {
+	return len(q.l) == 0 && len(q.r) == 0
+}
+
+func (q Deque) Size() int {
+	return len(q.l) + len(q.r)
+}
+
+func (q *Deque) PushFront(v int) {
+	q.l = append(q.l, v)
+}
+
+func (q *Deque) PushBack(v int) {
+	q.r = append(q.r, v)
+}
+
+func (q *Deque) PopFront() (v int) {
+	if len(q.l) > 0 {
+		q.l, v = q.l[:len(q.l)-1], q.l[len(q.l)-1]
+	} else {
+		v, q.r = q.r[0], q.r[1:]
+	}
+	return
+}
+
+func (q *Deque) PopBack() (v int) {
+	if len(q.r) > 0 {
+		q.r, v = q.r[:len(q.r)-1], q.r[len(q.r)-1]
+	} else {
+		v, q.l = q.l[0], q.l[1:]
+	}
+	return
+}
+
+func (q Deque) Front() int {
+	if len(q.l) > 0 {
+		return q.l[len(q.l)-1]
+	}
+	return q.r[0]
+}
+
+func (q Deque) Back() int {
+	if len(q.r) > 0 {
+		return q.r[len(q.r)-1]
+	}
+	return q.l[0]
+}
+
+func (q Deque) Get(i int) int {
+	if i < len(q.l) {
+		return q.l[len(q.l)-1-i]
+	}
+	return q.r[i-len(q.l)]
+}
+```
+
+```ts
+function maxResult(nums: number[], k: number): number {
+    const n = nums.length;
+    const f: number[] = Array(n).fill(0);
+    const q = new Deque<number>();
+    q.pushBack(0);
+    for (let i = 0; i < n; ++i) {
+        if (i - q.frontValue()! > k) {
+            q.popFront();
+        }
+        f[i] = nums[i] + f[q.frontValue()!];
+        while (!q.isEmpty() && f[i] >= f[q.backValue()!]) {
+            q.popBack();
+        }
+        q.pushBack(i);
+    }
+    return f[n - 1];
+}
+
+class Node<T> {
+    value: T;
+    next: Node<T> | null;
+    prev: Node<T> | null;
+
+    constructor(value: T) {
+        this.value = value;
+        this.next = null;
+        this.prev = null;
+    }
+}
+
+class Deque<T> {
+    private front: Node<T> | null;
+    private back: Node<T> | null;
+    private size: number;
+
+    constructor() {
+        this.front = null;
+        this.back = null;
+        this.size = 0;
+    }
+
+    pushFront(val: T): void {
+        const newNode = new Node(val);
+        if (this.isEmpty()) {
+            this.front = newNode;
+            this.back = newNode;
+        } else {
+            newNode.next = this.front;
+            this.front!.prev = newNode;
+            this.front = newNode;
+        }
+        this.size++;
+    }
+
+    pushBack(val: T): void {
+        const newNode = new Node(val);
+        if (this.isEmpty()) {
+            this.front = newNode;
+            this.back = newNode;
+        } else {
+            newNode.prev = this.back;
+            this.back!.next = newNode;
+            this.back = newNode;
+        }
+        this.size++;
+    }
+
+    popFront(): T | undefined {
+        if (this.isEmpty()) {
+            return undefined;
+        }
+        const value = this.front!.value;
+        this.front = this.front!.next;
+        if (this.front !== null) {
+            this.front.prev = null;
+        } else {
+            this.back = null;
+        }
+        this.size--;
+        return value;
+    }
+
+    popBack(): T | undefined {
+        if (this.isEmpty()) {
+            return undefined;
+        }
+        const value = this.back!.value;
+        this.back = this.back!.prev;
+        if (this.back !== null) {
+            this.back.next = null;
+        } else {
+            this.front = null;
+        }
+        this.size--;
+        return value;
+    }
+
+    frontValue(): T | undefined {
+        return this.front?.value;
+    }
+
+    backValue(): T | undefined {
+        return this.back?.value;
+    }
+
+    getSize(): number {
+        return this.size;
+    }
+
+    isEmpty(): boolean {
+        return this.size === 0;
+    }
+}
 ```
 
 <!-- tabs:end -->