Find Jobs involved in Weighted Job Scheduling

Given N jobs where every job is represented by following three elements of it.

1. Start Time
2. Finish Time
3. Profit or Value Associated

Find the subset of jobs associated with maximum profit such that no two jobs in the subset overlap.

Examples:

Input:  
Number of Jobs n = 4
Job Details {Start Time, Finish Time, Profit}
Job 1:  {1, 2, 50} 
Job 2:  {3, 5, 20}
Job 3:  {6, 19, 100}
Job 4:  {2, 100, 200}

Output: 
Jobs involved in maximum profit are
Job 1:  {1, 2, 50}
Job 4:  {2, 100, 200}

In previous post, we have discussed about Weighted Job Scheduling problem. However, the post only covered code related to finding maximum profit. In this post, we will also print the jobs invloved in maximum profit.

Let arr[0..n-1] be the input array of Jobs. We define an array DP[] such that DP[i] stores Jobs involved to achieve maximum profit of array arr[0..i]. i.e. DP[i] stores solution to subproblem arr[0..i]. The rest of algorithm remains same as discussed in previous post.

Below is its C++ implementation –

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for weighted job scheduling using Dynamic
// Programming and Binary Search
#include <bits/stdc++.h>
using namespace std;
  
// A job has start time, finish time and profit.
struct Job
{
    int start, finish, profit;
};
  
// to store subset of jobs
struct weightedJob
{
    // vector of Jobs
    vector<Job> job;
  
    // find profit associated with included Jobs
    int value;
};
  
// A utility function that is used for sorting events
// according to finish time
bool jobComparator(Job s1, Job s2)
{
    return (s1.finish < s2.finish);
}
  
// A Binary Search based function to find the latest job
// (before current job) that doesn't conflict with current
// job. "index" is index of the current job. This function
// returns -1 if all jobs before index conflict with it. The
// array jobs[] is sorted in increasing order of finish time
int latestNonConflict(Job jobs[], int index)
{
    // Initialize 'lo' and 'hi' for Binary Search
    int lo = 0, hi = index - 1;
  
    // Perform binary Search iteratively
    while (lo <= hi)
    {
        int mid = (lo + hi) / 2;
        if (jobs[mid].finish <= jobs[index].start)
        {
            if (jobs[mid + 1].finish <= jobs[index].start)
                lo = mid + 1;
            else
                return mid;
        }
        else
            hi = mid - 1;
    }
  
    return -1;
}
  
// The main function that finds the subset of jobs
// associated with maximum profit such that no two
// jobs in the subset overlap.
int findMaxProfit(Job arr[], int n)
{
    // Sort jobs according to finish time
    sort(arr, arr + n, jobComparator);
  
    // Create an array to store solutions of subproblems.
    // DP[i] stores the Jobs involved and their total profit
    // till arr[i] (including arr[i])
    weightedJob DP[n];
  
    // initialize DP[0] to arr[0]
    DP[0].value = arr[0].profit;
    DP[0].job.push_back(arr[0]);
  
    // Fill entries in DP[] using recursive property
    for (int i = 1; i < n; i++)
    {
        // Find profit including the current job
        int inclProf = arr[i].profit;
        int l = latestNonConflict(arr, i);
        if (l != - 1)
            inclProf += DP[l].value;
  
        // Store maximum of including and excluding
        if (inclProf > DP[i - 1].value)
        {
            DP[i].value = inclProf;
  
            // including previous jobs and current job
            DP[i].job = DP[l].job;
            DP[i].job.push_back(arr[i]);
  
        }
        else
            // excluding the current job
            DP[i] = DP[i - 1];
    }
  
    // DP[n - 1] stores the result
    cout << "Optimal Jobs for maximum profits are\n" ;
    for (int i=0; i<DP[n-1].job.size(); i++)
    {
        Job j = DP[n-1].job[i];
        cout << "(" << j.start << ", " << j.finish
             << ", " << j.profit << ")" << endl;
    }
    cout << "\nTotal Optimal profit is " << DP[n - 1].value;
}
  
// Driver program
int main()
{
    Job arr[] = {{3, 5, 20}, {1, 2, 50}, {6, 19, 100},
        {2, 100, 200} };
    int n = sizeof(arr)/sizeof(arr[0]);
  
    findMaxProfit(arr, n);
  
    return 0;
}

chevron_right






                        filter_none








Output:


Optimal Jobs for maximum profits are
(1, 2, 50)
(2, 100, 200)

Total Optimal profit is 250



This article is contributed by Aditya Goel. 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.


Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



          
          
          
          

            

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:

      
      
      
      

      

      
					
		

    Article Tags : 
Dynamic Programming

           	
Practice Tags : 
Dynamic Programming

        

         

         
 
         
        Be the First to upvote.

                

        



        
        
        
        
        

    

            

            3.2
            

            

             
                 Based on 10 vote(s)
                    

            
            
            
            
            
        

        
        

        

        

        

        

        

        


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