chore: add LeetCode daily solution

TechnoBlogger14o3 · TechnoBlogger14o3 · commit a31e3f7d0638 · 2025-09-18T02:01:02.000Z
diff --git a/Medium/2025-09-18-3408-Design-Task-Manager/explanation.md b/Medium/2025-09-18-3408-Design-Task-Manager/explanation.md
@@ -0,0 +1,34 @@
+# Design Task Manager (Medium)
+
+**Problem ID:** 3408  
+**Date:** 2025-09-18  
+**Link:** https://leetcode.com/problems/design-task-manager/
+
+## Approach
+
+To solve the "Design Task Manager" problem, we need to efficiently manage tasks associated with users, each having a priority. The core operations we need to support are adding, editing, removing, and executing tasks based on their priority and task ID.
+
+### Main Idea:
+The main idea is to utilize a priority queue (or max-heap) to keep track of tasks based on their priorities. This allows us to efficiently retrieve and execute the task with the highest priority. If multiple tasks share the same priority, we will use the task ID to break ties, ensuring that the task with the higher ID is executed first.
+
+### Data Structures:
+1. **Priority Queue (Max-Heap)**: This will store tasks in the format `(priority, taskId, userId)`. The priority queue will allow us to efficiently access and remove the task with the highest priority.
+2. **Hash Map (Dictionary)**: This will map `taskId` to a tuple `(priority, userId)` for quick access to task details when editing or removing tasks. This ensures that we can efficiently update the priority or remove a task without needing to search through the priority queue.
+
+### Operations:
+1. **Initialization**: Populate the priority queue and hash map with the initial list of tasks.
+2. **Add Task**: Insert the new task into the priority queue and hash map.
+3. **Edit Task**: Update the task's priority in the hash map, and reinsert it into the priority queue to maintain the correct order.
+4. **Remove Task**: Remove the task from the hash map. To ensure consistency in the priority queue, we can mark the task as removed and handle its removal lazily during the `execTop` operation.
+5. **Execute Top Task**: Continuously extract the top task from the priority queue until we find a task that is still valid (not marked for removal). Return the `userId` of the executed task and remove it from the hash map.
+
+### Complexity:
+- **Time Complexity**:
+  - Adding a task: O(log n) for insertion into the priority queue.
+  - Editing a task: O(log n) for reinserting into the priority queue after updating the hash map.
+  - Removing a task: O(1) for updating the hash map, but O(log n) for cleaning up the priority queue during execution.
+  - Executing the top task: O(log n) for each extraction from the priority queue, but may involve multiple extractions in the worst case if many tasks are marked as removed.
+  
+- **Space Complexity**: O(n) for storing tasks in both the priority queue and hash map.
+
+This approach ensures that all operations are efficient and can handle the constraints provided in the problem statement. By leveraging a combination of a priority queue and a hash map, we achieve both fast access and priority management for the tasks.
diff --git a/Medium/2025-09-18-3408-Design-Task-Manager/solution.java b/Medium/2025-09-18-3408-Design-Task-Manager/solution.java
@@ -0,0 +1,64 @@
+import java.util.*;
+
+class TaskManager {
+    private final Map<Integer, Task> taskMap;
+    private final PriorityQueue<Task> taskQueue;
+
+    public TaskManager(int[][] tasks) {
+        taskMap = new HashMap<>();
+        taskQueue = new PriorityQueue<>((a, b) -> {
+            if (b.priority != a.priority) {
+                return Integer.compare(b.priority, a.priority);
+            }
+            return Integer.compare(b.taskId, a.taskId);
+        });
+        for (int[] task : tasks) {
+            add(task[0], task[1], task[2]);
+        }
+    }
+
+    public void add(int userId, int taskId, int priority) {
+        Task newTask = new Task(userId, taskId, priority);
+        taskMap.put(taskId, newTask);
+        taskQueue.offer(newTask);
+    }
+
+    public void edit(int taskId, int newPriority) {
+        Task task = taskMap.get(taskId);
+        if (task != null) {
+            taskQueue.remove(task);
+            task.priority = newPriority;
+            taskQueue.offer(task);
+        }
+    }
+
+    public void rmv(int taskId) {
+        Task task = taskMap.remove(taskId);
+        if (task != null) {
+            taskQueue.remove(task);
+        }
+    }
+
+    public int execTop() {
+        while (!taskQueue.isEmpty()) {
+            Task topTask = taskQueue.poll();
+            if (topTask != null && taskMap.containsKey(topTask.taskId)) {
+                taskMap.remove(topTask.taskId);
+                return topTask.userId;
+            }
+        }
+        return -1;
+    }
+
+    private static class Task {
+        int userId;
+        int taskId;
+        int priority;
+
+        Task(int userId, int taskId, int priority) {
+            this.userId = userId;
+            this.taskId = taskId;
+            this.priority = priority;
+        }
+    }
+}
diff --git a/Medium/2025-09-18-3408-Design-Task-Manager/solution.js b/Medium/2025-09-18-3408-Design-Task-Manager/solution.js
@@ -0,0 +1,112 @@
+class TaskManager {
+    constructor(tasks) {
+        this.tasks = new Map();
+        this.maxHeap = new MaxHeap();
+        for (const [userId, taskId, priority] of tasks) {
+            this.tasks.set(taskId, { userId, priority });
+            this.maxHeap.insert({ userId, taskId, priority });
+        }
+    }
+
+    add(userId, taskId, priority) {
+        this.tasks.set(taskId, { userId, priority });
+        this.maxHeap.insert({ userId, taskId, priority });
+    }
+
+    edit(taskId, newPriority) {
+        const task = this.tasks.get(taskId);
+        if (task) {
+            this.tasks.set(taskId, { ...task, priority: newPriority });
+            this.maxHeap.insert({ userId: task.userId, taskId, priority: newPriority });
+        }
+    }
+
+    rmv(taskId) {
+        this.tasks.delete(taskId);
+    }
+
+    execTop() {
+        while (this.maxHeap.size() > 0) {
+            const { userId, taskId, priority } = this.maxHeap.extractMax();
+            if (this.tasks.has(taskId) && this.tasks.get(taskId).priority === priority) {
+                this.tasks.delete(taskId);
+                return userId;
+            }
+        }
+        return -1;
+    }
+}
+
+class MaxHeap {
+    constructor() {
+        this.heap = [];
+    }
+
+    insert(value) {
+        this.heap.push(value);
+        this.bubbleUp();
+    }
+
+    extractMax() {
+        if (this.heap.length === 0) return null;
+        const max = this.heap[0];
+        const end = this.heap.pop();
+        if (this.heap.length > 0) {
+            this.heap[0] = end;
+            this.bubbleDown();
+        }
+        return max;
+    }
+
+    size() {
+        return this.heap.length;
+    }
+
+    bubbleUp() {
+        let index = this.heap.length - 1;
+        const element = this.heap[index];
+        while (index > 0) {
+            const parentIndex = Math.floor((index - 1) / 2);
+            const parent = this.heap[parentIndex];
+            if (element.priority > parent.priority || (element.priority === parent.priority && element.taskId > parent.taskId)) {
+                this.heap[index] = parent;
+                index = parentIndex;
+            } else {
+                break;
+            }
+        }
+        this.heap[index] = element;
+    }
+
+    bubbleDown() {
+        let index = 0;
+        const length = this.heap.length;
+        const element = this.heap[0];
+        while (true) {
+            const leftChildIndex = 2 * index + 1;
+            const rightChildIndex = 2 * index + 2;
+            let leftChild, rightChild;
+            let swap = null;
+
+            if (leftChildIndex < length) {
+                leftChild = this.heap[leftChildIndex];
+                if (leftChild.priority > element.priority || (leftChild.priority === element.priority && leftChild.taskId > element.taskId)) {
+                    swap = leftChildIndex;
+                }
+            }
+
+            if (rightChildIndex < length) {
+                rightChild = this.heap[rightChildIndex];
+                if ((swap === null && (rightChild.priority > element.priority || (rightChild.priority === element.priority && rightChild.taskId > element.taskId))) ||
+                    (swap !== null && (rightChild.priority > leftChild.priority || (rightChild.priority === leftChild.priority && rightChild.taskId > leftChild.taskId)))) {
+                    swap = rightChildIndex;
+                }
+            }
+
+            if (swap === null) break;
+            this.heap[index] = this.heap[swap];
+            index = swap;
+        }
+        this.heap[index] = element;
+    }
+}
diff --git a/Medium/2025-09-18-3408-Design-Task-Manager/solution.py b/Medium/2025-09-18-3408-Design-Task-Manager/solution.py
@@ -0,0 +1,29 @@
+import heapq
+
+class TaskManager:
+    def __init__(self, tasks):
+        self.tasks = {}
+        self.heap = []
+        for userId, taskId, priority in tasks:
+            self.tasks[taskId] = (userId, priority)
+            heapq.heappush(self.heap, (-priority, -taskId, taskId))
+
+    def add(self, userId: int, taskId: int, priority: int) -> None:
+        self.tasks[taskId] = (userId, priority)
+        heapq.heappush(self.heap, (-priority, -taskId, taskId))
+
+    def edit(self, taskId: int, newPriority: int) -> None:
+        userId, _ = self.tasks[taskId]
+        self.tasks[taskId] = (userId, newPriority)
+        heapq.heappush(self.heap, (-newPriority, -taskId, taskId))
+
+    def rmv(self, taskId: int) -> None:
+        del self.tasks[taskId]
+
+    def execTop(self) -> int:
+        while self.heap:
+            priority, negTaskId, taskId = heapq.heappop(self.heap)
+            if taskId in self.tasks and self.tasks[taskId][1] == -priority:
+                del self.tasks[taskId]
+                return self.tasks[taskId][0]
+        return -1
diff --git a/README.md b/README.md
@@ -150,3 +150,4 @@ Each problem includes:
 - 2025-09-14 — [Vowel Spellchecker](https://leetcode.com/problems/vowel-spellchecker/) (Medium) → `Medium/2025-09-14-966-Vowel-Spellchecker`
 - 2025-09-15 — [Maximum Number of Words You Can Type](https://leetcode.com/problems/maximum-number-of-words-you-can-type/) (Easy) → `Easy/2025-09-15-1935-Maximum-Number-of-Words-You-Can-Type`
 - 2025-09-17 — [Design a Food Rating System](https://leetcode.com/problems/design-a-food-rating-system/) (Medium) → `Medium/2025-09-17-2353-Design-a-Food-Rating-System`
+- 2025-09-18 — [Design Task Manager](https://leetcode.com/problems/design-task-manager/) (Medium) → `Medium/2025-09-18-3408-Design-Task-Manager`
