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 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 
deadlines and profits
JobID  Deadline  Profit
  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
deadlines and profits
JobID   Deadline  Profit
  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 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.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// Program to find the maximum profit job sequence from a given array
// of jobs with deadlines and profits
#include<iostream>
#include<algorithm>
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<n; i++)
        slot[i] = false;
  
    // 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=min(n, arr[i].dead)-1; j>=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<n; i++)
       if (slot[i])
         cout << arr[result[i]].id << " ";
}
  
// Driver program to test methods
int main()
{
    Job arr[] = { {'a', 2, 100}, {'b', 1, 19}, {'c', 2, 27},
                   {'d', 1, 25}, {'e', 3, 15}};
    int n = sizeof(arr)/sizeof(arr[0]);
    cout << "Following is maximum profit sequence of jobsn";
    printJobScheduling(arr, n);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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<Job> arr, int t)
{
      
    // Length of array 
    int n = arr.size();
  
    // Sort all jobs according to 
    // decreasing order of profit 
    for(int i = 0; i < n; i++)
    {
       for(int j = 0; j < n - 1 - i; j++)
       {
          if (arr.get(j).profit < 
              arr.get(j + 1).profit)
          {
              Job temp = arr.get(j);
              arr.set(j, arr.get(j + 1));
              arr.set(j + 1, temp);
          }
       }
    }
  
    // 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<Job> arr = new ArrayList<Job>(); 
      
    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)); 
      
    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 

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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")
printJobScheduling(arr, 3) # Function Call
  
# This code is contributed 
# by Anubhav Raj Singh

chevron_right



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.

Job Sequencing Problem | Set 2 (Using Disjoint Set)

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

This article is contributed by Shubham. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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 :


40


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