解題思路

首先對所有的任務按照 提出時間，優先順序，所需時間進行排序，即提出時間相等時按照優先順序排序，優先順序也相等時按照所需時間進行排序。

可以維護一個長度為M的堆，M為程式設計師員的數量，這個堆中儲存的值是程式設計師完成某個任務的完成時間點，依次取排序後的任務，然後在堆中取一個程式設計師，取堆頂的那個，這個任務的完成時間即為提出任務時間和堆中取出的時間的較大值加上任務所需時間。然後再將這個時間更新進堆中。
需要注意的是輸出的時候是按照輸入的任務順序進行輸出的，因而需要儲存任務的編號，然後按照編號由小到大的順序輸出結果。

這個題並沒有在線上測試，線下寫的，不知道有沒得問題。。。。

import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;

class Task implements Comparable<Task> {
    int startTime;
    int needTime;
    int level;
    int sequence;

    @Override
    public int compareTo(Task o) {
        // TODO Auto-generated method stub
        if
 
 (startTime > o.startTime) {
            return 1;
        } else if (startTime < o.startTime) {
            return -1;
        } else {
            if (level > o.level) {
                return 1;
            } else if (level < o.level)
                return -1;
            else {
                if
 
 (needTime > o.needTime) {
                    return 1;
                } else if (needTime < o.needTime)
                    return -1;
                else {
                    return 0;
                }
            }
        }
    }
}

class FinishTime implements Comparable<FinishTime> {
    int sequence;
    int time;

    @Override
    public int compareTo(FinishTime o) {
        // TODO Auto-generated method stub
        return this.sequence > o.sequence ? 1 : (this.sequence < o.sequence ? -1 : 0);
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int M = sc.nextInt();
        int P = sc.nextInt();
        Task[] task = new Task[P];

        for (int i = 0; i < P; i++) {
            Task t = new Task();
            sc.nextInt();
            t.startTime = sc.nextInt();
            t.level = sc.nextInt();
            t.needTime = sc.nextInt();
            t.sequence = i;
            task[i] = t;
        }
        Arrays.sort(task);

        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(M);
        for (int i = 0; i < M; i++)
            priorityQueue.add(0);
        int index = 0;
        FinishTime[] result = new FinishTime[P];
        while (index < P) {
            int time = priorityQueue.poll();
            int finishTime = Math.max(task[index].startTime, time) + task[index].needTime;
            priorityQueue.add(finishTime);
            FinishTime t = new FinishTime();
            t.sequence = task[index].sequence;
            t.time = finishTime;
            result[index]=t;
            index++;
        }
        Arrays.sort(result);
        for(int i=0;i<P;i++)
            System.out.println(result[i].time);

    }
}