feat: add solutions to lc problem: No.2398 (doocs#3497)

No.2398.Maximum Number of Robots Within Budget

Author: yanglbme

solution/2300-2399/2398.Maximum Number of Robots Within Budget/README.md

@@ -87,18 +87,18 @@ class Solution:
         self, chargeTimes: List[int], runningCosts: List[int], budget: int
     ) -> int:
         q = deque()
-        ans = j = s = 0
-        for i, (a, b) in enumerate(zip(chargeTimes, runningCosts)):
-            while q and chargeTimes[q[-1]] <= a:
+        ans = s = l = 0
+        for r, (t, c) in enumerate(zip(chargeTimes, runningCosts)):
+            s += c
+            while q and chargeTimes[q[-1]] <= t:
                 q.pop()
-            q.append(i)
-            s += b
-            while q and chargeTimes[q[0]] + (i - j + 1) * s > budget:
-                if q[0] == j:
+            q.append(r)
+            while q and (r - l + 1) * s + chargeTimes[q[0]] > budget:
+                if q[0] == l:
                     q.popleft()
-                s -= runningCosts[j]
-                j += 1
-            ans = max(ans, i - j + 1)
+                s -= runningCosts[l]
+                l += 1
+            ans = max(ans, r - l + 1)
         return ans
 ```
 
@@ -109,23 +109,21 @@ class Solution {
     public int maximumRobots(int[] chargeTimes, int[] runningCosts, long budget) {
         Deque<Integer> q = new ArrayDeque<>();
         int n = chargeTimes.length;
-        long s = 0;
-        int j = 0;
         int ans = 0;
-        for (int i = 0; i < n; ++i) {
-            int a = chargeTimes[i], b = runningCosts[i];
-            while (!q.isEmpty() && chargeTimes[q.getLast()] <= a) {
+        long s = 0;
+        for (int l = 0, r = 0; r < n; ++r) {
+            s += runningCosts[r];
+            while (!q.isEmpty() && chargeTimes[q.peekLast()] <= chargeTimes[r]) {
                 q.pollLast();
             }
-            q.offer(i);
-            s += b;
-            while (!q.isEmpty() && chargeTimes[q.getFirst()] + (i - j + 1) * s > budget) {
-                if (q.getFirst() == j) {
+            q.offerLast(r);
+            while (!q.isEmpty() && (r - l + 1) * s + chargeTimes[q.peekFirst()] > budget) {
+                if (q.peekFirst() == l) {
                     q.pollFirst();
                 }
-                s -= runningCosts[j++];
+                s -= runningCosts[l++];
             }
-            ans = Math.max(ans, i - j + 1);
+            ans = Math.max(ans, r - l + 1);
         }
         return ans;
     }
@@ -140,19 +138,21 @@ public:
     int maximumRobots(vector<int>& chargeTimes, vector<int>& runningCosts, long long budget) {
         deque<int> q;
         long long s = 0;
-        int ans = 0, j = 0, n = chargeTimes.size();
-        for (int i = 0; i < n; ++i) {
-            int a = chargeTimes[i], b = runningCosts[i];
-            while (!q.empty() && chargeTimes[q.back()] <= a) q.pop_back();
-            q.push_back(i);
-            s += b;
-            while (!q.empty() && chargeTimes[q.front()] + (i - j + 1) * s > budget) {
-                if (q.front() == j) {
+        int ans = 0;
+        int n = chargeTimes.size();
+        for (int l = 0, r = 0; r < n; ++r) {
+            s += runningCosts[r];
+            while (q.size() && chargeTimes[q.back()] <= chargeTimes[r]) {
+                q.pop_back();
+            }
+            q.push_back(r);
+            while (q.size() && (r - l + 1) * s + chargeTimes[q.front()] > budget) {
+                if (q.front() == l) {
                     q.pop_front();
                 }
-                s -= runningCosts[j++];
+                s -= runningCosts[l++];
             }
-            ans = max(ans, i - j + 1);
+            ans = max(ans, r - l + 1);
         }
         return ans;
     }
@@ -162,26 +162,205 @@ public:
 #### Go
 
 ```go
-func maximumRobots(chargeTimes []int, runningCosts []int, budget int64) int {
+func maximumRobots(chargeTimes []int, runningCosts []int, budget int64) (ans int) {
+	q := Deque{}
 	s := int64(0)
-	ans, j := 0, 0
-	q := []int{}
-	for i, a := range chargeTimes {
-		for len(q) > 0 && chargeTimes[q[len(q)-1]] <= a {
-			q = q[:len(q)-1]
+	l := 0
+	for r, t := range chargeTimes {
+		s += int64(runningCosts[r])
+		for !q.Empty() && chargeTimes[q.Back()] <= t {
+			q.PopBack()
 		}
-		q = append(q, i)
-		s += int64(runningCosts[i])
-		for len(q) > 0 && int64(chargeTimes[q[0]])+int64(i-j+1)*s > budget {
-			if q[0] == j {
-				q = q[1:]
+		q.PushBack(r)
+		for !q.Empty() && int64(r-l+1)*s+int64(chargeTimes[q.Front()]) > budget {
+			if q.Front() == l {
+				q.PopFront()
 			}
-			s -= int64(runningCosts[j])
-			j++
+			s -= int64(runningCosts[l])
+			l++
 		}
-		ans = max(ans, i-j+1)
+		ans = max(ans, r-l+1)
 	}
-	return ans
+	return
+}
+
+// template
+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)]
+}
+```
+
+#### TypeScript
+
+```ts
+function maximumRobots(chargeTimes: number[], runningCosts: number[], budget: number): number {
+    const q = new Deque<number>();
+    const n = chargeTimes.length;
+    let [ans, s] = [0, 0];
+    for (let l = 0, r = 0; r < n; ++r) {
+        s += runningCosts[r];
+        while (!q.isEmpty() && chargeTimes[q.backValue()!] <= chargeTimes[r]) {
+            q.popBack();
+        }
+        q.pushBack(r);
+        while (!q.isEmpty() && (r - l + 1) * s + chargeTimes[q.frontValue()!] > budget) {
+            if (q.frontValue() === l) {
+                q.popFront();
+            }
+            s -= runningCosts[l++];
+        }
+        ans = Math.max(ans, r - l + 1);
+    }
+    return ans;
+}
+
+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;
+    }
 }
 ```