# Weighted Job Scheduling

Dynamic ProgrammingData StructureAlgorithms

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 := jobList.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 = jobList.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