# Job Sequencing Problem

• Difficulty Level : Medium
• Last Updated : 07 Sep, 2021

Given an array of jobs where every job has a deadline and associated profit if the job is finished before the deadline. It is also given that every job takes a single unit of time, so the minimum possible deadline for any job is 1. How to maximize total profit if only one job can be scheduled at a time.

Examples:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

```Input: Four Jobs with following
a      4        20
b      1        10
c      1        40
d      1        30
Output: Following is maximum
profit sequence of jobs
c, a

Input:  Five Jobs with following
a       2        100
b       1        19
c       2        27
d       1        25
e       3        15
Output: Following is maximum
profit sequence of jobs
c, a, e```

A Simple Solution is to generate all subsets of a given set of jobs and check individual subsets for the feasibility of jobs in that subset. Keep track of maximum profit among all feasible subsets. The time complexity of this solution is exponential.
This is a standard Greedy Algorithm problem.

Following is the algorithm.

1) Sort all jobs in decreasing order of profit.
2) Iterate on jobs in decreasing order of profit.For each job , do the following :
a)Find a time slot i, such that slot is empty and i < deadline and i is greatest.Put the job in
this slot and mark this slot filled.
b)If no such i exists, then ignore the job.

The Following is the implementation of the above algorithm.

## C++

 `// Program to find the maximum profit job sequence from a given array``// of jobs with deadlines and profits``#include``#include``using` `namespace` `std;`` ` `// A structure to represent a job``struct` `Job``{``   ``char` `id;     ``// Job Id``   ``int` `dead;    ``// Deadline of job``   ``int` `profit;  ``// Profit if job is over before or on deadline``};`` ` `// This function is used for sorting all jobs according to profit``bool` `comparison(Job a, Job b)``{``     ``return` `(a.profit > b.profit);``}`` ` `// Returns minimum number of platforms required``void` `printJobScheduling(Job arr[], ``int` `n)``{``    ``// Sort all jobs according to decreasing order of profit``    ``sort(arr, arr+n, comparison);`` ` `    ``int` `result[n]; ``// To store result (Sequence of jobs)``    ``bool` `slot[n];  ``// To keep track of free time slots`` ` `    ``// Initialize all slots to be free``    ``for` `(``int` `i=0; i=0; j--)``       ``{``          ``// Free slot found``          ``if` `(slot[j]==``false``)``          ``{``             ``result[j] = i;  ``// Add this job to result``             ``slot[j] = ``true``; ``// Make this slot occupied``             ``break``;``          ``}``       ``}``    ``}`` ` `    ``// Print the result``    ``for` `(``int` `i=0; i

## Java

 `// Program to find the maximum profit``// job sequence from a given array``// of jobs with deadlines and profits``import` `java.util.*;`` ` `class` `Job ``{``    ``// Each job has a unique-id,``    ``// profit and deadline``    ``char` `id;``    ``int` `deadline, profit;`` ` `    ``// Constructors``    ``public` `Job() {}`` ` `    ``public` `Job(``char` `id, ``int` `deadline, ``int` `profit)``    ``{``        ``this``.id = id;``        ``this``.deadline = deadline;``        ``this``.profit = profit;``    ``}`` ` `    ``// Function to schedule the jobs take 2``    ``// arguments arraylist and no of jobs to schedule``    ``void` `printJobScheduling(ArrayList arr, ``int` `t)``    ``{``        ``// Length of array``        ``int` `n = arr.size();`` ` `        ``// Sort all jobs according to``        ``// decreasing order of profit``        ``Collections.sort(arr,``                         ``(a, b) -> b.profit - a.profit);`` ` `        ``// To keep track of free time slots``        ``boolean` `result[] = ``new` `boolean``[t];`` ` `        ``// To store result (Sequence of jobs)``        ``char` `job[] = ``new` `char``[t];`` ` `        ``// Iterate through all given jobs``        ``for` `(``int` `i = ``0``; i < n; i++) ``        ``{``            ``// Find a free slot for this job``            ``// (Note that we start from the``            ``// last possible slot)``            ``for` `(``int` `j``                 ``= Math.min(t - ``1``, arr.get(i).deadline - ``1``);``                 ``j >= ``0``; j--) {`` ` `                ``// Free slot found``                ``if` `(result[j] == ``false``) ``                ``{``                    ``result[j] = ``true``;``                    ``job[j] = arr.get(i).id;``                    ``break``;``                ``}``            ``}``        ``}`` ` `        ``// Print the sequence``        ``for` `(``char` `jb : job) ``        ``{``            ``System.out.print(jb + ``" "``);``        ``}``        ``System.out.println();``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``ArrayList arr = ``new` `ArrayList();`` ` `        ``arr.add(``new` `Job(``'a'``, ``2``, ``100``));``        ``arr.add(``new` `Job(``'b'``, ``1``, ``19``));``        ``arr.add(``new` `Job(``'c'``, ``2``, ``27``));``        ``arr.add(``new` `Job(``'d'``, ``1``, ``25``));``        ``arr.add(``new` `Job(``'e'``, ``3``, ``15``));``       ` `        ``// Function call``        ``System.out.println(``"Following is maximum "``                           ``+ ``"profit sequence of jobs"``);`` ` `        ``Job job = ``new` `Job();`` ` `        ``// Calling function``        ``job.printJobScheduling(arr, ``3``);``    ``}``}`` ` `// This code is contributed by Prateek Gupta`

## Python3

 `# Program to find the maximum profit``# job sequence from a given array``# of jobs with deadlines and profits`` ` `# function to schedule the jobs take 2``# arguments array and no of jobs to schedule`` ` ` ` `def` `printJobScheduling(arr, t):`` ` `    ``# length of array``    ``n ``=` `len``(arr)`` ` `    ``# Sort all jobs according to``    ``# decreasing order of profit``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(n ``-` `1` `-` `i):``            ``if` `arr[j][``2``] < arr[j ``+` `1``][``2``]:``                ``arr[j], arr[j ``+` `1``] ``=` `arr[j ``+` `1``], arr[j]`` ` `    ``# To keep track of free time slots``    ``result ``=` `[``False``] ``*` `t`` ` `    ``# To store result (Sequence of jobs)``    ``job ``=` `[``'-1'``] ``*` `t`` ` `    ``# Iterate through all given jobs``    ``for` `i ``in` `range``(``len``(arr)):`` ` `        ``# Find a free slot for this job``        ``# (Note that we start from the``        ``# last possible slot)``        ``for` `j ``in` `range``(``min``(t ``-` `1``, arr[i][``1``] ``-` `1``), ``-``1``, ``-``1``):`` ` `            ``# Free slot found``            ``if` `result[j] ``is` `False``:``                ``result[j] ``=` `True``                ``job[j] ``=` `arr[i][``0``]``                ``break`` ` `    ``# print the sequence``    ``print``(job)`` ` ` ` `# Driver COde``arr ``=` `[[``'a'``, ``2``, ``100``],  ``# Job Array``       ``[``'b'``, ``1``, ``19``],``       ``[``'c'``, ``2``, ``27``],``       ``[``'d'``, ``1``, ``25``],``       ``[``'e'``, ``3``, ``15``]]`` ` ` ` `print``(``"Following is maximum profit sequence of jobs"``)`` ` `# Function Call``printJobScheduling(arr, ``3``) `` ` `# This code is contributed``# by Anubhav Raj Singh`

## C#

 `// C# Program to find the maximum profit``// job sequence from a given array``// of jobs with deadlines and profits`` ` `using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG : IComparer``{``    ``public` `int` `Compare(Job x, Job y)``    ``{``        ``if` `(x.profit == 0 || y.profit== 0)``        ``{``            ``return` `0;``        ``}``           ` `        ``// CompareTo() method``        ``return` `(y.profit).CompareTo(x.profit);``           ` `    ``}``}`` ` ` ` `public` `class` `Job{``     ` `    ``// Each job has a unique-id,``    ``// profit and deadline``    ``char` `id;``    ``public` `int` `deadline, profit;``  ` `    ``// Constructors``    ``public` `Job() {}``  ` `    ``public` `Job(``char` `id, ``int` `deadline, ``int` `profit)``    ``{``        ``this``.id = id;``        ``this``.deadline = deadline;``        ``this``.profit = profit;``    ``}``  ` `    ``// Function to schedule the jobs take 2``    ``// arguments arraylist and no of jobs to schedule``    ``void` `printJobScheduling(List arr, ``int` `t)``    ``{``        ``// Length of array``        ``int` `n = arr.Count;``  ` `        ``GFG gg = ``new` `GFG();``        ``// Sort all jobs according to``        ``// decreasing order of profit``        ``arr.Sort(gg);``  ` `        ``// To keep track of free time slots``        ``bool``[] result = ``new` `bool``[t];``  ` `        ``// To store result (Sequence of jobs)``        ``char``[] job = ``new` `char``[t];``  ` `        ``// Iterate through all given jobs``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``// Find a free slot for this job``            ``// (Note that we start from the``            ``// last possible slot)``            ``for` `(``int` `j``                 ``= Math.Min(t - 1, arr[i].deadline - 1);``                 ``j >= 0; j--) {``  ` `                ``// Free slot found``                ``if` `(result[j] == ``false``)``                ``{``                    ``result[j] = ``true``;``                    ``job[j] = arr[i].id;``                    ``break``;``                ``}``            ``}``        ``}``  ` `        ``// Print the sequence``        ``foreach` `(``char` `jb ``in` `job)``        ``{``            ``Console.Write(jb + ``" "``);``        ``}``        ``Console.WriteLine();``    ``}``  ` `    ``// Driver code``    ``static` `public` `void` `Main ()``    ``{``         ` `        ``List arr = ``new` `List();``  ` `        ``arr.Add(``new` `Job(``'a'``, 2, 100));``        ``arr.Add(``new` `Job(``'b'``, 1, 19));``        ``arr.Add(``new` `Job(``'c'``, 2, 27));``        ``arr.Add(``new` `Job(``'d'``, 1, 25));``        ``arr.Add(``new` `Job(``'e'``, 3, 15));``        ` `        ``// Function call``        ``Console.WriteLine(``"Following is maximum "``                           ``+ ``"profit sequence of jobs"``);``  ` `        ``Job job = ``new` `Job();``  ` `        ``// Calling function``        ``job.printJobScheduling(arr, 3);``         ` `    ``}``}`` ` `// This code is contributed by avanitracchadiya2155.`

## Javascript

 ``
Output
```Following is maximum profit sequence of jobs
c a e ```

The Time Complexity of the above solution is O(n2). It can be optimized using Priority Queue(max heap).

The algorithm goes as follow:

• Sort the jobs based on their deadlines.
• Iterate from the end and calculate the available slots between every two consecutive deadlines. Include the profit, deadline, and job ID of ith job in the max heap.
• While the slots are available and there are jobs left in the max heap, include the job ID with maximum profit and deadline in the result.
• Sort the result array based on their deadlines.

Here is the implementation of the above algorithm.

## Python3

 `# Program to find the maximum profit``# job sequence from a given array``# of jobs with deadlines and profits``import` `heapq`` ` ` ` `def` `printJobScheduling(arr):``    ``n ``=` `len``(arr)`` ` `    ``# arr[i] = job_id, arr[i] = deadline, arr[i] = profit`` ` `    ``# sorting the array on the``    ``# basis of their deadlines``    ``arr.sort(key``=``lambda` `x: x[``1``])`` ` `    ``# initialise the result array and maxHeap``    ``result ``=` `[]``    ``maxHeap ``=` `[]`` ` `    ``# starting the iteration from the end``    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``):`` ` `        ``# calculate slots between two deadlines``        ``if` `i ``=``=` `0``:``            ``slots_available ``=` `arr[i][``1``]``        ``else``:``            ``slots_available ``=` `arr[i][``1``] ``-` `arr[i ``-` `1``][``1``]`` ` `        ``# include the profit of job(as priority), deadline``        ``# and job_id in maxHeap``        ``# note we push negative value in maxHeap to convert``        ``# min heap to max heap in python``        ``heapq.heappush(maxHeap, (``-``arr[i][``2``], arr[i][``1``], arr[i][``0``]))`` ` `        ``while` `slots_available ``and` `maxHeap:`` ` `            ``# get the job with max_profit``            ``profit, deadline, job_id ``=` `heapq.heappop(maxHeap)`` ` `            ``# reduce the slots``            ``slots_available ``-``=` `1`` ` `            ``# include the job in the result array``            ``result.append([job_id, deadline])`` ` `    ``# jobs included might be shuffled``    ``# sort the result array by their deadlines``    ``result.sort(key``=``lambda` `x: x[``1``])`` ` `    ``for` `job ``in` `result:``        ``print``(job[``0``], end``=``" "``)``    ``print``()`` ` ` ` `# Driver COde``arr ``=` `[[``'a'``, ``2``, ``100``],  ``# Job Array``       ``[``'b'``, ``1``, ``19``],``       ``[``'c'``, ``2``, ``27``],``       ``[``'d'``, ``1``, ``25``],``       ``[``'e'``, ``3``, ``15``]]`` ` `print``(``"Following is maximum profit sequence of jobs"``)`` ` `# Function Call``printJobScheduling(arr)`` ` `# This code is contributed``# by Shivam Bhagat`
Output
```Following is maximum profit sequence of jobs
a c e ```

Time complexity : O(nlog(n))

Space complexity : O(n)

It can also be optimized using Disjoint Set Data Structure. Please refer to the below post for details.

Sources:
http://ocw.mit.edu/courses/civil-and-environmental-engineering/1-204-computer-algorithms-in-systems-engineering-spring-2010/lecture-notes/MIT1_204S10_lec10.pdf