# Job Sequencing Problem

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 the 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:

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 given set of jobs and check individual subset for 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 above algorithm.

 // 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 reqquired void printJobScheduling(Job arr[], int n) {     // Sort all jobs according to decreasing order of prfit     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

 # 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

Output
Following is maximum profit sequence of jobs
c a e

Time Complexity of the above solution is O(n2). It can be optimized using Disjoint Set Data Structure. Please refer 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