Process tasks using servers

Array Heap (Priority Queue)

42.0% acceptance

Feb 25, 2026

1026

289

You are given two 0-indexed integer arrays servers and tasks. Tasks are assigned to free servers using a queue. At second j, task j is added. Assign each task to the free server with smallest weight (tie: smallest index). Return the array of server indices for each task.

Solution

Rust

Time O(n²)

Space O(n)

LeetCode

solution.rs

use std::collections::BinaryHeap;
use std::cmp::Reverse;

impl Solution {
  pub fn assign_tasks(servers: Vec<i32>, tasks: Vec<i32>) -> Vec<i32> {
    let n = servers.len();
    let m = tasks.len();
    let mut ans = vec![0i32; m];

    // free: min-heap of (weight, index)
    let mut free: BinaryHeap<Reverse<(i32, usize)>> = (0..n)
      .map(|i| Reverse((servers[i], i)))
      .collect();

    // busy: min-heap of (free_time, weight, index)
    let mut busy: BinaryHeap<Reverse<(i64, i32, usize)>> = BinaryHeap::new();

    let mut time: i64 = 0;

    for j in 0..m {
      time = time.max(j as i64);

      // Release servers that become free by 'time'
      while let Some(&Reverse((ft, w, idx))) = busy.peek() {
        if ft <= time {
          busy.pop();
          free.push(Reverse((w, idx)));
        } else {
          break;
        }
      }

      // If no free server, advance time to earliest free
      if free.is_empty() {
        if let Some(&Reverse((ft, _, _))) = busy.peek() {
          time = ft;
          while let Some(&Reverse((ft2, w, idx))) = busy.peek() {
            if ft2 <= time {
              busy.pop();
              free.push(Reverse((w, idx)));
            } else {
              break;
            }
          }
        }
      }

      let Reverse((w, idx)) = free.pop().unwrap();
      ans[j] = idx as i32;
      busy.push(Reverse((time + tasks[j] as i64, w, idx)));
    }

    ans
  }
}