LeetCode 1882: Process Tasks Using Servers Solution

Master LeetCode problem 1882 (Process Tasks Using Servers), a medium challenge, with our optimized solutions in Java, C++, and Python. Explore detailed explanations, test your code in our interactive editor, and prepare for coding interviews.

1882. Process Tasks Using Servers

Medium

Array Heap (Priority Queue)

Problem Explanation

Explanation

To solve this problem, we can simulate the process of assigning tasks to servers based on the given conditions. We will use a min heap to keep track of the available servers at any given time. We will also maintain a priority queue to keep track of the tasks waiting to be processed.

We initialize two priority queues - one for servers (based on weight and index) and one for tasks (based on time).
We iterate through the tasks and assign them to servers based on the conditions specified in the problem.
For each task, we check if there are any available servers. If there are, we assign the task to the server with the smallest weight and index.
If there are no available servers, we wait until a server becomes available and assign the task accordingly.
We update the server's availability time and continue the process until all tasks are assigned.

The time complexity of this approach is O(nlogn), where n is the number of tasks. The space complexity is O(n) to store the servers and tasks in priority queues.

Solution Code

import java.util.*;

class Solution {
    public int[] assignTasks(int[] servers, int[] tasks) {
        PriorityQueue<int[]> availableServers = new PriorityQueue<>((a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
        for (int i = 0; i < servers.length; i++) {
            availableServers.offer(new int[]{servers[i], i});
        }

        PriorityQueue<int[]> busyServers = new PriorityQueue<>((a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
        PriorityQueue<int[]> taskQueue = new PriorityQueue<>((a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);

        int[] assignment = new int[tasks.length];
        int currentTime = 0;

        for (int i = 0; i < tasks.length; i++) {
            currentTime = Math.max(currentTime, i);
            while (!busyServers.isEmpty() && busyServers.peek()[0] <= currentTime) {
                int[] server = busyServers.poll();
                availableServers.offer(new int[]{server[1], server[2]});
            }

            if (availableServers.isEmpty()) {
                currentTime = busyServers.peek()[0];
                while (!busyServers.isEmpty() && busyServers.peek()[0] <= currentTime) {
                    int[] server = busyServers.poll();
                    availableServers.offer(new int[]{server[1], server[2]});
                }
            }

            int[] server = availableServers.poll();
            assignment[i] = server[1];
            busyServers.offer(new int[]{currentTime + tasks[i], server[0], server[1]});
        }

        return assignment;
    }
}

Try It Yourself

Loading code editor...

Frequently Asked Questions

How to solve LeetCode 1882 (Process Tasks Using Servers)?

This page provides optimized solutions for LeetCode problem 1882 (Process Tasks Using Servers) in Java, C++, and Python, along with a detailed explanation and an interactive code editor to test your code.

What is the time complexity of LeetCode 1882 (Process Tasks Using Servers)?

The time complexity for LeetCode 1882 (Process Tasks Using Servers) varies by solution. Check the detailed explanation section for specific complexities in Java, C++, and Python implementations.

Can I run code for LeetCode 1882 on DevExCode?

Yes, DevExCode provides an interactive code editor where you can write, test, and run your code for LeetCode 1882 in Java, C++, or Python.

Back to LeetCode Solutions