Job Scheduling with Deadlines in DSA Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

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

The goal is to schedule jobs to maximize total profit while completing each job before its deadline.

beginner

In Job Scheduling with Deadlines, what does each job typically have?

Each job has a deadline by which it must be completed and a profit earned if completed on time.

intermediate

Why do we sort jobs by profit in descending order in the greedy approach?

Sorting by profit ensures we try to schedule the most profitable jobs first to maximize total profit.

intermediate

How do we find a slot for a job in the greedy algorithm for Job Scheduling with Deadlines?

We try to place the job in the latest available slot before its deadline to keep earlier slots free for other jobs.

advanced

What data structure can efficiently help track free time slots in Job Scheduling with Deadlines?

An array or disjoint set (union-find) can be used to track free slots efficiently.

What is the first step in the greedy algorithm for Job Scheduling with Deadlines?

A Sort jobs by descending profit

B Sort jobs by ascending deadline

C Schedule jobs randomly

D Schedule jobs by ascending profit

Sorting jobs by descending profit ensures we consider the most profitable jobs first.

If a job's deadline is 3, which slot should we try to assign it to first?

A Slot 1

B Slot 2

C Slot 3

D Slot 4

We try to assign the job to the latest available slot before or on its deadline, which is slot 3.

What happens if no free slot is available before a job's deadline?

A The job is skipped

B The job is scheduled anyway

C The job is scheduled after the deadline

D The job's profit is doubled

If no free slot is available before the deadline, the job cannot be scheduled and is skipped.

Which of these is NOT a property of jobs in Job Scheduling with Deadlines?

A Deadline

B Duration longer than 1 unit

C Completion before deadline

D Profit

Jobs are assumed to take 1 unit of time; longer durations are not considered in this problem.

What is the main reason to schedule jobs in the latest possible slot before deadline?

A To schedule jobs randomly

B To minimize profit

C To avoid scheduling any job

D To maximize the number of scheduled jobs

Scheduling jobs as late as possible frees earlier slots for other jobs, maximizing total scheduled jobs.

Explain the greedy approach to solve Job Scheduling with Deadlines.

Think about scheduling the most profitable jobs first and placing them as late as possible.

Describe how to track free slots when scheduling jobs with deadlines.

Imagine a calendar with time slots you mark as busy or free.

Practice

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

easy

A. Maximize the number of jobs scheduled regardless of profit

B. Minimize the number of jobs scheduled

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

D. Maximize the total profit by scheduling jobs before their deadlines

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

   We want to maximize total profit, not just count or order jobs.

3. Final Answer:

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

4. Quick Check:

   Goal = Maximize profit [OK]

Hint: Focus on maximizing profit within deadlines [OK]

Common Mistakes:

• Thinking it's about scheduling all jobs
• Ignoring profit values
• Scheduling jobs without deadline checks

2. Which of the following Java code snippets correctly sorts an array of jobs by their profit in descending order?

easy

A. Arrays.sort(jobs, (a, b) -> a.profit - b.profit);

B. Arrays.sort(jobs, Comparator.comparingInt(j -> j.deadline));

C. Arrays.sort(jobs, (a, b) -> b.profit - a.profit);

D. Arrays.sort(jobs);

Solution

1. Step 1: Identify sorting by profit descending

   To sort descending by profit, compare b.profit - a.profit.

2. Step 2: Check lambda syntax correctness

   Arrays.sort(jobs, (a, b) -> b.profit - a.profit); uses (a, b) -> b.profit - a.profit which sorts descending.

3. Final Answer:

   Arrays.sort(jobs, (a, b) -> b.profit - a.profit); -> Option C

4. Quick Check:

   Descending profit sort = Arrays.sort(jobs, (a, b) -> b.profit - a.profit); [OK]

Hint: Use (b.profit - a.profit) for descending sort [OK]

Common Mistakes:

• Using a.profit - b.profit for descending order
• Sorting by deadline instead of profit
• Using default sort without comparator

3. Given the following jobs with (id, deadline, profit):
Job[] jobs = { new Job('a', 2, 100), new Job('b', 1, 19), new Job('c', 2, 27), new Job('d', 1, 25), new Job('e', 3, 15) };
What is the maximum profit achievable by scheduling these jobs before their deadlines?

medium

A. 142

B. 185

C. 100

D. 115

Solution

1. Step 1: Sort jobs by profit descending

   Sorted: a(100,2), d(25,1), c(27,2), b(19,1), e(15,3)

2. Step 2: Schedule jobs greedily before deadlines

   Schedule 'a' at slot 2, 'c' at slot 1 (slot 2 taken), 'e' at slot 3. Total profit = 100 + 27 + 15 = 142.

3. Final Answer:

   142 -> Option A

4. Quick Check:

   Profit sum = 142 [OK]

Hint: Schedule highest profit jobs first in latest free slot [OK]

Common Mistakes:

• Scheduling jobs without sorting by profit
• Overlapping jobs in same slot
• Ignoring deadlines

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

Arrays.sort(jobs, (a, b) -> a.profit - b.profit);
boolean[] slot = new boolean[maxDeadline + 1];
for (Job job : jobs) {
  for (int j = job.deadline; j > 0; j--) {
    if (!slot[j]) {
      slot[j] = true;
      totalProfit += job.profit;
      break;
    }
  }
}

medium

A. Sorting should be in descending order of profit

B. Slot array size should be maxDeadline, not maxDeadline + 1

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

D. No error, code is correct

Solution

1. Step 1: Check sorting order

   Sorting by a.profit - b.profit sorts ascending, but we need descending to maximize profit.

2. Step 2: Verify scheduling logic

   The slot array and inner loop correctly find latest free slot before deadline.

3. Final Answer:

   Sorting should be in descending order of profit -> Option A

4. Quick Check:

   Profit descending sort needed [OK]

Hint: Sort jobs by profit descending to maximize total profit [OK]

Common Mistakes:

• Sorting ascending by profit
• Incorrect slot array size off by one
• Loop direction confusion

5. You have jobs with deadlines and profits:
Job[] jobs = { new Job('x', 4, 70), new Job('y', 1, 80), new Job('z', 1, 30), new Job('w', 2, 100), new Job('v', 3, 40) };
Using the job scheduling algorithm, which jobs will be scheduled to maximize profit and what is the total profit?

hard

A. Jobs w, y, x scheduled; Total profit = 250

B. Jobs y, w, v, x scheduled; Total profit = 290

C. Jobs y, w, x scheduled; Total profit = 250

D. Jobs y, w, v scheduled; Total profit = 220

Solution

1. Step 1: Sort jobs by profit descending

   Sorted: w(100,2), y(80,1), x(70,4), v(40,3), z(30,1)

2. Step 2: Schedule jobs greedily in latest free slot before deadline

   Schedule y at slot 1, w at slot 2, v at slot 3, x at slot 4. z cannot be scheduled (slot 1 taken). Total profit = 80+100+40+70=290.

3. Final Answer:

   Jobs y, w, v, x scheduled; Total profit = 290 -> Option B

4. Quick Check:

   Profit sum = 290 [OK]

Hint: Schedule highest profit jobs in latest free slots first [OK]

Common Mistakes:

• Scheduling jobs ignoring deadlines
• Not choosing latest free slot
• Missing highest profit jobs