1
class Solution {
2
  public int[] assignTasks(int[] servers, int[] tasks) {
3

4
    PriorityQueue<int[]> availableServer =
5
        new PriorityQueue<int[]>((a, b) -> (a[1] != b[1] ? (a[1] - b[1]) : (a[0] - b[0])));
6
    for (int i = 0; i < servers.length; i++) {
7
      availableServer.add(new int[] {i, servers[i]});
8
    }
9

10
    // int[[] arr,
11
    // arr[0] - server index
12
    // arr[1] - server weight
13
    // arr[2] - free time
14
    PriorityQueue<int[]> processingServer =
15
        new PriorityQueue<int[]>(
16
            (a, b) ->
17
                (a[2] != b[2]
18
                    ? a[2] - b[2]
19
                    : // try to sort increasing order of free time
20
                    a[1] != b[1]
21
                        ? a[1] - b[1]
22
                        : // try to sort increasing order of server weight
23
                        a[0] - b[0] // sort increasing order of server index
24
                ));
25

26
    int[] result = new int[tasks.length];
27

28
    for (int i = 0; i < tasks.length; i++) {
29

30
      while (!processingServer.isEmpty() && processingServer.peek()[2] <= i) {
31
        int serverIndex = processingServer.remove()[0];
32
        availableServer.add(new int[] {serverIndex, servers[serverIndex]});
33
      }
34

35
      int currentTaskTimeRequired = tasks[i];
36

37
      int[] server;
38

39
      // when current task will free the server done
40
      int freeTime = currentTaskTimeRequired;
41

42
      if (!availableServer.isEmpty()) {
43
        server = availableServer.remove();
44
        freeTime += i;
45
      } else {
46
        server = processingServer.remove();
47
        // append previous time
48
        freeTime += server[2];
49
      }
50

51
      int serverIndex = server[0];
52
      processingServer.add(new int[] {serverIndex, servers[serverIndex], freeTime});
53

54
      // assign this server to current task
55
      result[i] = serverIndex;
56
    }
57

58
    return result;
59
  }
60
}