Job Scheduling with Deadlines in DSA C++ - Build from Scratch

Job Scheduling with Deadlines

📖 Scenario: You are managing a small workshop where several jobs need to be completed. Each job has a deadline and a profit if finished on time. You want to schedule the jobs to maximize your total profit without missing deadlines.

🎯 Goal: Build a program that schedules jobs with deadlines to maximize profit. You will create the job list, set the maximum deadline, schedule the jobs, and print the scheduled jobs in order.

📋 What You'll Learn

Create a list of jobs with exact IDs, deadlines, and profits

Create a variable for the maximum deadline

Implement the job scheduling logic to maximize profit

Print the scheduled jobs in the order they will be done

💡 Why This Matters

🌍 Real World

Job scheduling is used in factories, computer task management, and project planning to maximize efficiency and profit.

💼 Career

Understanding job scheduling algorithms is important for software developers working on operating systems, manufacturing software, and optimization problems.

1

Create the list of jobs

Create a vector of jobs called jobs where each job is a struct with id (char), deadline (int), and profit (int). Add these exact jobs: {'a', 2, 100}, {'b', 1, 19}, {'c', 2, 27}, {'d', 1, 25}, {'e', 3, 15}.

DSA C++

#include 
#include 
using namespace std;

struct Job {
    char id;
    int deadline;
    int profit;
};

int main() {
    // Create vector jobs with given jobs
    // Your code here

Hint

Use vector<Job> and initialize it with the exact jobs inside curly braces.

2

Set the maximum deadline

Create an integer variable called maxDeadline and set it to 3.

DSA C++

#include 
#include 
using namespace std;

struct Job {
    char id;
    int deadline;
    int profit;
};

int main() {
    vector jobs = {
        {'a', 2, 100},
        {'b', 1, 19},
        {'c', 2, 27},
        {'d', 1, 25},
        {'e', 3, 15}
    };
    // Create int maxDeadline and set to 3
    // Your code here

Hint

Just create an integer variable maxDeadline and assign it the value 3.

3

Schedule the jobs to maximize profit

Sort the jobs vector in descending order by profit. Then create a vector of chars called result of size maxDeadline initialized with '-'. For each job in jobs, find a free slot from job.deadline - 1 down to 0 and assign the job's id to that slot in result if free.

DSA C++

#include 
#include 
#include 
using namespace std;

struct Job {
    char id;
    int deadline;
    int profit;
};

int main() {
    vector jobs = {
        {'a', 2, 100},
        {'b', 1, 19},
        {'c', 2, 27},
        {'d', 1, 25},
        {'e', 3, 15}
    };
    int maxDeadline = 3;
    // Sort jobs by profit descending
    // Create vector result of size maxDeadline with '-'
    // Schedule jobs in result
    // Your code here

Hint

Use sort with a lambda to sort by profit descending. Create result vector filled with '-'. Then for each job, check slots from deadline - 1 down to 0 and assign if free.

4

Print the scheduled jobs

Print the scheduled jobs in result vector in order, separated by spaces.

DSA C++

Hint

Print each character in result separated by spaces on one line.

Practice

1. What is the main goal of the Job Scheduling with Deadlines problem?

easy

A. Minimize the number of jobs scheduled

B. Schedule jobs in the order they appear without considering deadlines

C. Maximize total profit by scheduling jobs before their deadlines

D. Maximize the number of jobs scheduled regardless of profit

Solution

1. Step 1: Understand the problem objective

   The problem aims to schedule jobs so that each job finishes before its deadline to earn profit.

2. Step 2: Identify the optimization goal

   The goal is to maximize the total profit earned by selecting jobs that fit within their deadlines.

3. Final Answer:

   Maximize total profit by scheduling jobs before their deadlines -> Option C

4. Quick Check:

   Goal = Maximize profit [OK]

Hint: Focus on profit maximization within deadlines [OK]

Common Mistakes:

• Ignoring deadlines and scheduling all jobs
• Trying to schedule jobs in input order
• Maximizing number of jobs instead of profit

2. Which of the following is the correct C++ syntax to sort jobs by profit in descending order using std::sort and a custom comparator?

easy

A. std::sort(jobs.begin(), jobs.end());

B. std::sort(jobs.begin(), jobs.end(), [](Job a, Job b){ return a.profit > b.profit; });

C. std::sort(jobs.begin(), jobs.end(), compare); // where compare returns a.profit < b.profit

D. std::sort(jobs.begin(), jobs.end(), [](Job a, Job b){ return a.profit < b.profit; });

Solution

1. Step 1: Understand sorting by profit descending

   To sort descending, comparator should return true if first profit is greater than second.

2. Step 2: Check lambda comparator syntax

   std::sort(jobs.begin(), jobs.end(), [](Job a, Job b){ return a.profit > b.profit; }); uses a lambda returning a.profit > b.profit, which sorts descending correctly.

3. Final Answer:

   std::sort(jobs.begin(), jobs.end(), [](Job a, Job b){ return a.profit > b.profit; }); -> Option B

4. Quick Check:

   Descending sort = a.profit > b.profit [OK]

Hint: Use comparator returning true if first > second for descending [OK]

Common Mistakes:

• Using < instead of > for descending order
• Not providing a comparator for custom sorting
• Using default sort which sorts ascending

3. Given jobs with deadlines and profits:
jobs = [{id:1, deadline:2, profit:100}, {id:2, deadline:1, profit:19}, {id:3, deadline:2, profit:27}, {id:4, deadline:1, profit:25}, {id:5, deadline:3, profit:15}]
What is the maximum profit achievable by scheduling these jobs?

medium

A. 185

B. 190

C. 160

D. 142

Solution

1. Step 1: Sort jobs by profit descending

   Sorted jobs: (1,100,2), (3,27,2), (4,25,1), (2,19,1), (5,15,3)

2. Step 2: Schedule jobs greedily before deadlines

   Schedule job 1 at slot 2, job 4 at slot 1, job 5 at slot 3. Jobs 3 and 2 cannot fit without conflict.

3. Step 3: Calculate total profit

   Profit = 100 + 25 + 15 = 140. But check if job 3 can replace job 4 for better profit: job 3 (27) > job 4 (25), so schedule job 3 at slot 2, job 4 at slot 1 is not possible because slot 1 is taken by job 4. Instead, schedule job 3 at slot 2, job 2 at slot 1 (profit 19), job 5 at slot 3 (15). Total = 100 + 27 + 15 = 142. Better is job 1 (100), job 3 (27), job 4 (25) at slots 2,1,3 respectively? Slot 3 deadline is 3, so job 4 deadline 1 can't be at 3. So best is job 1 (100), job 3 (27), job 4 (25) at slots 2,1, no slot for job 5. Total 152. Actually, slot 3 is free for job 5 (15). So schedule job 1 at 2, job 4 at 1, job 5 at 3 = 100+25+15=140. Or job 1 at 2, job 3 at 1, job 5 at 3 = 100+27+15=142. Or job 1 at 2, job 4 at 1, job 3 can't fit. So max profit is 142.

4. Final Answer:

   142 -> Option D

5. Quick Check:

   Max profit = 142 [OK]

Hint: Sort by profit, schedule greedily before deadlines [OK]

Common Mistakes:

• Scheduling jobs ignoring deadlines
• Not sorting by profit first
• Overlapping jobs in same time slot

4. Identify the error in the following C++ code snippet for job scheduling:

struct Job { int id, deadline, profit; };
std::vector<Job> jobs = ...;
std::sort(jobs.begin(), jobs.end(), [](Job a, Job b){ return a.profit < b.profit; });
std::vector<int> slot(maxDeadline + 1, -1);
for (auto &job : jobs) {
  for (int j = job.deadline; j > 0; j--) {
    if (slot[j] == -1) {
      slot[j] = job.id;
      break;
    }
  }
}

medium

A. Sorting comparator sorts ascending instead of descending

B. Slots vector size should be maxDeadline, not maxDeadline + 1

C. Inner loop should run from 1 to job.deadline, not reverse

D. Job IDs should not be stored in slots, profits should be stored

Solution

1. Step 1: Analyze sorting comparator

   The comparator returns true if a.profit < b.profit, which sorts ascending by profit.

2. Step 2: Understand scheduling logic

   Jobs must be sorted descending by profit to schedule highest profit jobs first.

3. Final Answer:

   Sorting comparator sorts ascending instead of descending -> Option A

4. Quick Check:

   Comparator must sort descending [OK]

Hint: Sort jobs descending by profit for correct scheduling [OK]

Common Mistakes:

• Using ascending sort comparator
• Incorrect slot vector size off by one
• Loop direction confusion

5. You have 6 jobs with deadlines and profits:
jobs = [{id:1, d:4, p:70}, {id:2, d:1, p:80}, {id:3, d:1, p:30}, {id:4, d:1, p:100}, {id:5, d:3, p:40}, {id:6, d:2, p:20}]
Using the job scheduling algorithm, what is the maximum profit and which jobs are scheduled?

hard

A. Profit: 230; Jobs scheduled: 4 -> 1 -> 5 -> 6

B. Profit: 220; Jobs scheduled: 4 -> 2 -> 5 -> 6

C. Profit: 240; Jobs scheduled: 4 -> 2 -> 1 -> 5

D. Profit: 210; Jobs scheduled: 4 -> 1 -> 3 -> 5

Solution

1. Step 1: Sort jobs by profit descending

   Sorted: (4,100,1), (2,80,1), (1,70,4), (5,40,3), (3,30,1), (6,20,2)

2. Step 2: Schedule jobs greedily before deadlines

   Schedule job 4 at slot 1 (deadline 1), job 6 at slot 2 (deadline 2), job 5 at slot 3 (deadline 3), job 1 at slot 4 (deadline 4). Jobs 2 and 3 cannot fit because slot 1 is taken by job 4.

3. Step 3: Calculate total profit and jobs scheduled

   Profit = 100 + 20 + 40 + 70 = 230; Scheduled jobs in order of slots: 4 -> 6 -> 5 -> 1 (slots 1,2,3,4)

4. Final Answer:

   Profit: 230; Jobs scheduled: 4 -> 6 -> 5 -> 1 -> Option A

5. Quick Check:

   Max profit = 230 with jobs 4,6,5,1 [OK]

Hint: Sort by profit, assign latest free slot before deadline [OK]

Common Mistakes:

• Scheduling multiple jobs in same slot
• Ignoring deadlines when scheduling
• Not sorting jobs by profit first