Weighted Job Scheduling

A list of different jobs is given, with the starting time, the ending time and profit of that job are also provided for those jobs. Our task is to find a subset of jobs, where the profit is maximum and no jobs are overlapping each other.

In this algorithm, we use a table to store the results of sub-problems and using the results of subproblems, the whole problem can be solved in a bottom-up manner.

The time complexity of this algorithm is O(n^2), but we can change it to O(n Log n) by using a binary search method to search con-conflicting jobs.

Input and Output

Input:
The start time, finish time and profit of some jobs as matrix form. And number of jobs. Here 4 jobs are present.
3   5  25
1   2  50
6  15  75
2 100 100

Output:
The maximum profit 150.
The job sequence is job 2, job 4, or job 2, job 1, job 3. for both cases the max profit is 150 here.

Algorithm

findMaxProfit(jobList, n)

Input: The job list and number of jobs.

Output: Maximum profit from the jobs.

Begin
sort job list according to their ending time
define table to store results
table[0] := jobList[0].profit

for i := 1 to n-1, do
nonConflict := find jobs which is not conflicting with others
if any non-conflicting job found, then
if addProfit > table[i - 1], then
else
table[i] := table[i-1]
done
result := table[n-1]
return result
End

Example

#include <iostream>
#include <algorithm>
using namespace std;

struct Job {
int start, end, profit;
};

bool comp(Job job1, Job job2) {
return (job1.end < job2.end);
}

int nonConflictJob(Job jobList[], int i) {       //non conflicting job of jobList[i]
for (int j=i-1; j>=0; j--) {
if (jobList[j].end <= jobList[i-1].start)
return j;
}
return -1;
}

int findMaxProfit(Job jobList[], int n) {
sort(jobList, jobList+n, comp);           //sort jobs based on the ending time

int *table = new int[n];       //create jon table
table[0] = jobList[0].profit;

for (int i=1; i<n; i++) {
// Find profit including the current job
int l = nonConflictJob(jobList, i);
if (l != -1)
}

int result = table[n-1];
delete[] table;                 //clear table from memory
return result;
}

int main() {
Job jobList[] = {
{3, 5, 25},
{1, 2, 50},
{6, 15, 75},
{2, 100, 100}
};

int n = 4;
cout << "The maximum profit: " << findMaxProfit(jobList, n);
return 0;
}

Output

The maximum profit: 150