# Scheduling priority tasks in limited time and minimizing loss

Given n tasks with arrival time, priority and number of time units they need. We need to schedule these tasks on a single resource. The objective is to arrange tasks such that maximum priority tasks are taken. Objective is to minimize sum of product of priority and left time of tasks that are not scheduled due to limited time. This criteria simply means that the scheduling should cause minimum possible loss.

Examples:

```Input : Total time = 3
Task1: arrival = 1, units = 2, priority = 300
Task2: arrival = 2, units = 2, priority = 100
Output : 100
Explanation : Two tasks are given and time to finish
them is 3 units. First task arrives at time 1 and it
needs 2 units. Since no other task is running at that
time, we take it. 1 unit of task 1 is over. Now task 2
(300 > 100) thus 1 more unit  of task 1 is employed.
Now 1 unit of time is left and we have 2 units of task
2 to be done. So simply 1 unit of task 2 is done and
the answer is ( units of task 2 left X priority of
task 2 ) = 1 X 100 = 100

Input : Total Time = 3
Task1: arrival = 1, units = 1, priority = 100
Task2: arrival = 2, units = 2, priority = 300
Output : 0
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

We use a priority queue and schedule one unit of task at a time.

1. Initialize total loss as sum of each priority and units. The idea is to initialize result as maximum, then one by one subtract priorities of tasks that are scheduled.
2. Sort all tasks according to arrival time.
3. Process through each unit of time from 1 to total time. For current time, pick the highest priority task that is available. Schedule 1 unit of this task and subtract its priority from total loss.

Below is C++ implementation of above steps.

 `// C++ code for task scheduling on basis ` `// of priority and arrival time ` `#include "bits/stdc++.h" ` `using` `namespace` `std; ` ` `  `// t is total time. n is number of tasks. ` `// arriv[] stores arrival times. units[] ` `// stores units of time required. prior[] ` `// stores priorities. ` `int` `minLoss(``int` `n, ``int` `t, ``int` `arriv[], ` `            ``int` `units[],  ``int` `prior[]) ` `{ ` `    ``// Calculating maximum possible answer ` `    ``// that could be calculated. Later we ` `    ``// will subtract the tasks from it ` `    ``// accordingly. ` `    ``int` `ans = 0; ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``ans += prior[i] * units[i]; ` ` `  `    ``// Pushing tasks in a vector so that they ` `    ``// could be sorted according with their ` `    ``// arrival time ` `    ``vector > v; ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``v.push_back({ arriv[i], i }); ` ` `  `    ``// Sorting tasks in vector identified by ` `    ``// index and arrival time with respect ` `    ``// to their arrival time ` `    ``sort(v.begin(), v.end()); ` ` `  `    ``// Priority queue to hold tasks to be ` `    ``// scheduled. ` `    ``priority_queue > pq; ` ` `  `    ``// Consider one unit of time at a time. ` `    ``int` `ptr = 0; ``// index in sorted vector ` `    ``for` `(``int` `i = 1; i <= t; i++) { ` ` `  `        ``// Push all tasks that have arrived at ` `        ``// this time. Note that the tasks that ` `        ``// arrived earlier and could not be scheduled ` `        ``// are already in pq. ` `        ``while` `(ptr < n and v[ptr].x == i) { ` `            ``pq.push({ prior[v[ptr].y], units[v[ptr].y] }); ` `            ``ptr++; ` `        ``} ` ` `  `        ``// Remove top priority task to be scheduled ` `        ``// at time i. ` `        ``if` `(!pq.empty()) { ` `            ``auto` `tmp = pq.top(); ` `            ``pq.pop(); ` ` `  `            ``// Removing 1 unit of task ` `            ``// from answer as we could ` `            ``// schedule it. ` `            ``ans -= tmp.x; ` `            ``tmp.y--; ` `            ``if` `(tmp.y) ` `                ``pq.push(tmp); ` `        ``} ` `    ``} ` ` `  `    ``return` `ans; ` `} ` ` `  `// driver code ` `int` `main() ` `{ ` `    ``int` `n = 2, t = 3; ` `    ``int` `arriv[] = { 1, 2 }; ` `    ``int` `units[] = { 2, 2 }; ` `    ``int` `prior[] = { 100, 300 }; ` ` `  `    ``printf``(``"%d\n"``,  minLoss(n, t, arriv, units, prior)); ` `    ``return` `0; ` `} `

Output:

```100
```

This article is contributed by Parth Trehan. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.