Given two arrays: deadline[] and profit[], where the index of deadline[] represents a job ID, and deadline[i] denotes the deadline for that job and profit[i] represents profit of doing ith job. Each job takes exactly one unit of time to complete, and only one job can be scheduled at a time. A job earns its corresponding profit only if it is completed within its deadline.
The objective is to determine:
- The maximum profit that can be obtained by scheduling the jobs optimally.
- The total number of jobs completed to achieve this maximum profit.
Examples:
Input: deadline[] = [4, 1, 1, 1], profit[] = [20, 10, 40, 30]
Output: 2 60
Explanation: We select 1st and 3rd jobs. All jobs except first job have a deadline of 1, thus only one of these can be selected along with the first job with the total profit gain of 20 + 40 = 60.
Input: deadline[] = [2, 1, 2, 1, 1], profit[] = [100, 19, 27, 25, 15]
Output: 2 127
Explanation: The first and third job have a deadline of 2, thus both of them can be completed and other jobs have a deadline of 1, thus any one of them can be completed. Both the jobs with a deadline of 2 is having the maximum associated profit, so these two will be completed, with the total profit gain of 100 + 27 = 127.
[Naive Approach] Greedy Approach and Sorting - O(n ^ 2) Time and O(n) Space
Step by Step implementation:
- Store jobs as pairs of (Profit, Deadline): Since we need to prioritize jobs with higher profits, we pair the profit and deadline together.
- Sort Jobs Based on Profit: We sort the
jobs array in descending order of profit so that we prioritize scheduling the most profitable jobs first. - Create a Slot Array: We create a
slot[] array of size n (equal to the number of jobs) initialized with zeroes. This array will help track which time slots are occupied. - Iterate Over Each Job and Try to Schedule It:
- For each job, check if it can be placed in an available time slot.
- The job should be scheduled as late as possible but before its deadline.
- If an empty slot is found, schedule the job there, increment the job count, and add its profit to the total.
- After processing all jobs, return the number of jobs completed and the total profit earned.
C++ // C++ program to solve job sequencing // problem with maximu profit #include<bits/stdc++.h> using namespace std; vector<int> jobSequencing(vector<int> &deadline, vector<int> &profit) { int n = deadline.size(); // total job count which is done int cnt = 0; // total profit earned int totProfit = 0; // pair the profit and deadline of // all the jos together vector<pair<int, int>> jobs; for (int i = 0; i < n; i++) { jobs.push_back({profit[i], deadline[i]}); } // sort the jobs based on profit // in decreasing order sort(jobs.begin(), jobs.end(), greater<pair<int, int>>()); // array to check time slot for job vector<int> slot(n, 0); for (int i = 0; i < n; i++) { int start = min(n, jobs[i].second) - 1; for (int j = start; j >= 0; j--) { // if slot is empty if (slot[j] == 0) { slot[j] = 1; cnt++; totProfit+= jobs[i].first; break; } } } return {cnt, totProfit}; } int main() { vector<int> deadline = {2, 1, 2, 1, 1}; vector<int> profit = {100, 19, 27, 25, 15}; vector<int> ans = jobSequencing(deadline, profit); cout<<ans[0]<<" "<<ans[1]; return 0; } // Java program to solve job sequencing // problem with maximum profit import java.util.*; class GfG { static ArrayList<Integer> jobSequencing(int[] deadline, int[] profit) { int n = deadline.length; // total job count which is done int cnt = 0; // total profit earned int totProfit = 0; // pair the profit and deadline of all the jobs together ArrayList<int[]> jobs = new ArrayList<>(); for (int i = 0; i < n; i++) { jobs.add(new int[]{profit[i], deadline[i]}); } // sort the jobs based on profit in decreasing order jobs.sort((a, b) -> Integer.compare(b[0], a[0])); // array to check time slot for job int[] slot = new int[n]; for (int i = 0; i < n; i++) { int start = Math.min(n, jobs.get(i)[1]) - 1; for (int j = start; j >= 0; j--) { // if slot is empty if (slot[j] == 0) { slot[j] = 1; cnt++; totProfit += jobs.get(i)[0]; break; } } } ArrayList<Integer> result = new ArrayList<>(); result.add(cnt); result.add(totProfit); return result; } public static void main(String[] args) { int[] deadline = {2, 1, 2, 1, 1}; int[] profit = {100, 19, 27, 25, 15}; ArrayList<Integer> ans = jobSequencing(deadline, profit); System.out.println(ans.get(0) + " " + ans.get(1)); } } # Pyhton program to solve job sequencing # problem with maximu profit def jobSequencing(deadline, profit): n = len(deadline) # total job count which is done cnt = 0 # total profit earned totProfit = 0 # pair the profit and deadline of # all the jos together and sort it in decreasing order jobs = sorted(zip(profit, deadline), reverse=True) # array to check time slot for job slot = [0] * n for i in range(n): start = min(n, jobs[i][1]) - 1 for j in range(start, -1, -1): # if slot is empty if slot[j] == 0: slot[j] = 1 cnt += 1 totProfit += jobs[i][0] break return [cnt, totProfit] if __name__ == "__main__": deadline = [2, 1, 2, 1, 1] profit = [100, 19, 27, 25, 15] ans = jobSequencing(deadline, profit) print(ans[0], ans[1])
// C# program to solve job sequencing // problem with maximu profit using System; using System.Collections.Generic; class GfG { public static List<int> JobSequencing(int[] deadline, int[] profit) { int n = deadline.Length; // total job count which is done int cnt = 0; // total profit earned int totProfit = 0; // pair the profit and deadline of // all the jos together List<Tuple<int, int>> jobs = new List<Tuple<int, int>>(); for (int i = 0; i < n; i++) { jobs.Add(new Tuple<int, int>(profit[i], deadline[i])); } // sort the jobs based on profit // in decreasing order jobs.Sort((a, b) => b.Item1.CompareTo(a.Item1)); // array to check time slot for job int[] slot = new int[n]; for (int i = 0; i < n; i++) { int start = Math.Min(n, jobs[i].Item2) - 1; for (int j = start; j >= 0; j--) { // if slot is empty if (slot[j] == 0) { slot[j] = 1; cnt++; totProfit += jobs[i].Item1; break; } } } return new List<int> { cnt, totProfit }; } static void Main() { int[] deadline = { 2, 1, 2, 1, 1 }; int[] profit = { 100, 19, 27, 25, 15 }; List<int> ans = JobSequencing(deadline, profit); Console.WriteLine(ans[0] + " " + ans[1]); } } // JavaScript program to solve job sequencing // problem with maximum profit function jobSequencing(deadline, profit) { let n = deadline.length; // total job count which is done let cnt = 0; // total profit earned let totProfit = 0; // pair the profit and deadline of // all the jos together let jobs = []; for (let i = 0; i < n; i++) { jobs.push([profit[i], deadline[i]]); } // sort the jobs based on profit // in decreasing order jobs.sort((a, b) => b[0] - a[0]); // array to check time slot for job let slot = new Array(n).fill(0); for (let i = 0; i < n; i++) { let start = Math.min(n, jobs[i][1]) - 1; for (let j = start; j >= 0; j--) { // if slot is empty if (slot[j] === 0) { slot[j] = 1; cnt++; totProfit += jobs[i][0]; break; } } } return [cnt, totProfit]; } // Driver Code const deadline = [2, 1, 2, 1, 1]; const profit = [100, 19, 27, 25, 15]; const ans = jobSequencing(deadline, profit); console.log(ans[0], ans[1]); [Expected Approach] Greedy Approach, Sorting and Priority Queue - O(n * log(n)) Time and O(n) Space
The main idea is to sort the jobs based on their deadlines in ascending order. This ensures that jobs with earlier deadlines are processed first, preventing situations where a job with a short deadline remains unscheduled because a job with a later deadline was chosen instead. We use a min-heap to keep track of the selected jobs, allowing us to efficiently replace lower-profit jobs when a more profitable job becomes available.
Step by Step implementation:
- Store jobs as pairs of (Deadline, Profit).
- Sort Jobs Based on Deadline: We sort the
jobs array in ascending order of deadline so that we prioritize jobs with earlier deadlines are considered first. - For each job
(deadline, profit) in the sorted list:- If the job can be scheduled within its deadline (i.e., the number of jobs scheduled so far is less than the deadline), push its profit into the heap.
- If the heap is full (equal to deadline), replace the existing lowest profit job with the current job if it has a higher profit.
- This ensures that we always keep the most profitable jobs within the available slots.
- Traverse through the heap and store the total profit and the count of jobs.
C++ // C++ program to solve job sequencing // problem with maximum profit #include<bits/stdc++.h> using namespace std; vector<int> jobSequencing(vector<int> &deadline, vector<int> &profit) { int n = deadline.size(); vector<int> ans = {0, 0}; // pair the profit and deadline of // all the jos together vector<pair<int, int>> jobs; for (int i = 0; i < n; i++) { jobs.push_back({deadline[i], profit[i]}); } // sort the jobs based on deadline // in ascending order sort(jobs.begin(), jobs.end()); // to maintain the scheduled jobs based on profit priority_queue<int, vector<int>, greater<int>> pq; for (const auto &job : jobs) { // if job can be scheduled within its deadline if (job.first > pq.size()) pq.push(job.second); // Replace the job with the lowest profit else if (!pq.empty() && pq.top() < job.second) { pq.pop(); pq.push(job.second); } } while (!pq.empty()) { ans[1] += pq.top(); pq.pop(); ans[0]++; } return ans; } int main() { vector<int> deadline = {2, 1, 2, 1, 1}; vector<int> profit = {100, 19, 27, 25, 15}; vector<int> ans = jobSequencing(deadline, profit); cout<<ans[0]<<" "<<ans[1]; return 0; } // Java program to solve job sequencing // problem with maximum profit import java.util.*; public class GfG { static ArrayList<Integer> jobSequencing(int[] deadline, int[] profit) { int n = deadline.length; ArrayList<Integer> ans = new ArrayList<>(Arrays.asList(0, 0)); // Pair the profit and deadline of all the jobs together List<int[]> jobs = new ArrayList<>(); for (int i = 0; i < n; i++) { jobs.add(new int[]{deadline[i], profit[i]}); } // Sort the jobs based on deadline in ascending order jobs.sort(Comparator.comparingInt(a -> a[0])); // Min-heap to maintain the scheduled jobs based on profit PriorityQueue<Integer> pq = new PriorityQueue<>(); for (int[] job : jobs) { // If job can be scheduled within its deadline if (job[0] > pq.size()) { pq.add(job[1]); } // Replace the job with the lowest profit else if (!pq.isEmpty() && pq.peek() < job[1]) { pq.poll(); pq.add(job[1]); } } while (!pq.isEmpty()) { ans.set(1, ans.get(1) + pq.poll()); ans.set(0, ans.get(0) + 1); } return ans; } public static void main(String[] args) { int[] deadline = {2, 1, 2, 1, 1}; int[] profit = {100, 19, 27, 25,15}; ArrayList<Integer> result = jobSequencing(deadline, profit); System.out.println(result.get(0) + " " + result.get(1)); } } # Python program to solve job sequencing # problem with maximum profit import heapq def jobSequencing(deadline, profit): n = len(deadline) ans = [0, 0] # pair the profit and deadline of # all the jos together jobs = [(deadline[i], profit[i]) for i in range(n)] # sort the jobs based on deadline # in ascending order jobs.sort() # to maintain the scheduled jobs based on profit pq = [] for job in jobs: # if job can be scheduled within its deadline if job[0] > len(pq): heapq.heappush(pq, job[1]) # Replace the job with the lowest profit elif pq and pq[0] < job[1]: heapq.heappop(pq) heapq.heappush(pq, job[1]) while pq: ans[1] += heapq.heappop(pq) ans[0] += 1 return ans if __name__ == "__main__": deadline = [2, 1, 2, 1, 1] profit = [100, 19, 27, 25,15] ans = jobSequencing(deadline, profit) print(ans[0], ans[1])
// C# program to solve job sequencing // problem with maximum profit using System; using System.Collections.Generic; class GfG { static List<int> jobSequencing(int[] deadline, int[] profit) { int n = deadline.Length; List<int> ans = new List<int> { 0, 0 }; // pair the profit and deadline of // all the jobs together List<(int, int)> jobs = new List<(int, int)>(); for (int i = 0; i < n; i++) { jobs.Add((deadline[i], profit[i])); } // sort the jobs based on deadline // in ascending order jobs.Sort((a, b) => a.Item1.CompareTo(b.Item1)); // to maintain the scheduled jobs based on profit SortedSet<int> pq = new SortedSet<int>(); foreach (var job in jobs) { // if job can be scheduled within its deadline if (pq.Count < job.Item1) { pq.Add(job.Item2); } // Replace the job with the lowest profit else if (pq.Count > 0 && pq.Min < job.Item2) { pq.Remove(pq.Min); pq.Add(job.Item2); } } foreach (int value in pq) { ans[1] += value; ans[0]++; } return ans; } public static void Main() { int[] deadline = { 2, 1, 2, 1, 1 }; int[] profit = { 100, 19, 27, 25, 15 }; List<int> ans = jobSequencing(deadline, profit); Console.WriteLine(ans[0] + " " + ans[1]); } } // JavaScript program to solve job sequencing // problem with maximum profit class MinHeap { constructor() { this.heap = []; } push(val) { this.heap.push(val); this.heapifyUp(); } pop() { if (this.heap.length === 1) return this.heap.pop(); let top = this.heap[0]; this.heap[0] = this.heap.pop(); this.heapifyDown(); return top; } top() { return this.heap[0]; } size() { return this.heap.length; } heapifyUp() { let idx = this.heap.length - 1; while (idx > 0) { let parent = Math.floor((idx - 1) / 2); if (this.heap[parent] <= this.heap[idx]) break; [this.heap[parent], this.heap[idx]] = [this.heap[idx], this.heap[parent]]; idx = parent; } } heapifyDown() { let idx = 0; while (2 * idx + 1 < this.heap.length) { let left = 2 * idx + 1, right = 2 * idx + 2; let smallest = left; if (right < this.heap.length && this.heap[right] < this.heap[left]) smallest = right; if (this.heap[idx] <= this.heap[smallest]) break; [this.heap[idx], this.heap[smallest]] = [this.heap[smallest], this.heap[idx]]; idx = smallest; } } } function jobSequencing(deadline, profit) { let n = deadline.length; let ans = [0, 0]; // pair the profit and deadline of // all the jobs together let jobs = []; for (let i = 0; i < n; i++) { jobs.push([deadline[i], profit[i]]); } // sort the jobs based on deadline // in ascending order jobs.sort((a, b) => a[0] - b[0]); // to maintain the scheduled jobs based on profit let pq = new MinHeap(); for (let job of jobs) { // if job can be scheduled within its deadline if (job[0] > pq.size()) { pq.push(job[1]); } // Replace the job with the lowest profit else if (pq.size() > 0 && pq.top() < job[1]) { pq.pop(); pq.push(job[1]); } } while (pq.size() > 0) { ans[1] += pq.pop(); ans[0]++; } return ans; } // Driver Code let deadline = [2, 1, 2, 1, 1]; let profit = [100, 19, 27, 25, 15]; let ans = jobSequencing(deadline, profit); console.log(ans[0] + " " + ans[1]); [Alternate Approach] Using Disjoint Set - O(n * log(d)) Time and O(d) Space
The job sequencing can also be done using disjoint set based on the maximum deadline of all the jobs. This approach is explained in article Job Sequencing - Using Disjoint Set.
Similar Reads
Greedy Algorithms Greedy algorithms are a class of algorithms that make locally optimal choices at each step with the hope of finding a global optimum solution. At every step of the algorithm, we make a choice that looks the best at the moment. To make the choice, we sometimes sort the array so that we can always get
3 min read
Greedy Algorithm Tutorial Greedy is an algorithmic paradigm that builds up a solution piece by piece, always choosing the next piece that offers the most obvious and immediate benefit. Greedy algorithms are used for optimization problems. An optimization problem can be solved using Greedy if the problem has the following pro
9 min read
Greedy Algorithms General Structure A greedy algorithm solves problems by making the best choice at each step. Instead of looking at all possible solutions, it focuses on the option that seems best right now.Example of Greedy Algorithm - Fractional KnapsackProblem structure:Most of the problems where greedy algorithms work follow thes
5 min read
Difference between Greedy Algorithm and Divide and Conquer Algorithm Greedy algorithm and divide and conquer algorithm are two common algorithmic paradigms used to solve problems. The main difference between them lies in their approach to solving problems. Greedy Algorithm:The greedy algorithm is an algorithmic paradigm that follows the problem-solving heuristic of m
3 min read
Greedy Approach vs Dynamic programming Greedy approach and Dynamic programming are two different algorithmic approaches that can be used to solve optimization problems. Here are the main differences between these two approaches: Greedy Approach:The greedy approach makes the best choice at each step with the hope of finding a global optim
2 min read
Comparison among Greedy, Divide and Conquer and Dynamic Programming algorithm Greedy algorithm, divide and conquer algorithm, and dynamic programming algorithm are three common algorithmic paradigms used to solve problems. Here's a comparison among these algorithms:Approach:Greedy algorithm: Makes locally optimal choices at each step with the hope of finding a global optimum.
4 min read
Standard Greedy algorithms
Activity Selection Problem | Greedy Algo-1Given n activities with start times in start[] and finish times in finish[], find the maximum number of activities a single person can perform without overlap. A person can only do one activity at a time. Examples: Input: start[] = [1, 3, 0, 5, 8, 5], finish[] = [2, 4, 6, 7, 9, 9]Output: 4Explanatio
13 min read
Job Sequencing ProblemGiven two arrays: deadline[] and profit[], where the index of deadline[] represents a job ID, and deadline[i] denotes the deadline for that job and profit[i] represents profit of doing ith job. Each job takes exactly one unit of time to complete, and only one job can be scheduled at a time. A job ea
13 min read
Huffman Coding | Greedy Algo-3Huffman coding is a lossless data compression algorithm. The idea is to assign variable-length codes to input characters, lengths of the assigned codes are based on the frequencies of corresponding characters. The variable-length codes assigned to input characters are Prefix Codes, means the codes (
12 min read
Huffman DecodingWe have discussed Huffman Encoding in a previous post. In this post, decoding is discussed. Examples: Input Data: AAAAAABCCCCCCDDEEEEEFrequencies: A: 6, B: 1, C: 6, D: 2, E: 5 Encoded Data: 0000000000001100101010101011111111010101010 Huffman Tree: '#' is the special character usedfor internal nodes
15 min read
Water Connection ProblemYou are given n houses in a colony, numbered from 1 to n, and p pipes connecting these houses. Each house has at most one outgoing pipe and at most one incoming pipe. Your goal is to install tanks and taps efficiently.A tank is installed at a house that has one outgoing pipe but no incoming pipe.A t
8 min read
Greedy Algorithm for Egyptian FractionEvery positive fraction can be represented as sum of unique unit fractions. A fraction is unit fraction if numerator is 1 and denominator is a positive integer, for example 1/3 is a unit fraction. Such a representation is called Egyptian Fraction as it was used by ancient Egyptians. Following are a
11 min read
Policemen catch thievesGiven an array arr, where each element represents either a policeman (P) or a thief (T). The objective is to determine the maximum number of thieves that can be caught under the following conditions:Each policeman (P) can catch only one thief (T).A policeman can only catch a thief if the distance be
12 min read
Fitting Shelves ProblemGiven length of wall w and shelves of two lengths m and n, find the number of each type of shelf to be used and the remaining empty space in the optimal solution so that the empty space is minimum. The larger of the two shelves is cheaper so it is preferred. However cost is secondary and first prior
9 min read
Assign Mice to HolesThere are N Mice and N holes are placed in a straight line. Each hole can accommodate only 1 mouse. A mouse can stay at his position, move one step right from x to x + 1, or move one step left from x to x -1. Any of these moves consumes 1 minute. Assign mice to holes so that the time when the last m
8 min read
Greedy algorithm on Array
Minimum product subset of an arrayINTRODUCTION: The minimum product subset of an array refers to a subset of elements from the array such that the product of the elements in the subset is minimized. To find the minimum product subset, various algorithms can be used, such as greedy algorithms, dynamic programming, and branch and boun
13 min read
Maximize array sum after K negations using SortingGiven an array of size n and an integer k. We must modify array k number of times. In each modification, we can replace any array element arr[i] by -arr[i]. The task is to perform this operation in such a way that after k operations, the sum of the array is maximum.Examples : Input : arr[] = [-2, 0,
10 min read
Minimum sum of product of two arraysFind the minimum sum of Products of two arrays of the same size, given that k modifications are allowed on the first array. In each modification, one array element of the first array can either be increased or decreased by 2.Examples: Input : a[] = {1, 2, -3} b[] = {-2, 3, -5} k = 5 Output : -31 Exp
14 min read
Minimum sum of absolute difference of pairs of two arraysGiven two arrays a[] and b[] of equal length n. The task is to pair each element of array a to an element in array b, such that sum S of absolute differences of all the pairs is minimum.Suppose, two elements a[i] and a[j] (i != j) of a are paired with elements b[p] and b[q] of b respectively, then p
7 min read
Minimum increment/decrement to make array non-IncreasingGiven an array a, your task is to convert it into a non-increasing form such that we can either increment or decrement the array value by 1 in the minimum changes possible. Examples : Input : a[] = {3, 1, 2, 1}Output : 1Explanation : We can convert the array into 3 1 1 1 by changing 3rd element of a
11 min read
Sorting array with reverse around middleConsider the given array arr[], we need to find if we can sort array with the given operation. The operation is We have to select a subarray from the given array such that the middle element(or elements (in case of even number of elements)) of subarray is also the middle element(or elements (in case
6 min read
Sum of Areas of Rectangles possible for an arrayGiven an array, the task is to compute the sum of all possible maximum area rectangles which can be formed from the array elements. Also, you can reduce the elements of the array by at most 1. Examples: Input: a = {10, 10, 10, 10, 11, 10, 11, 10} Output: 210 Explanation: We can form two rectangles o
13 min read
Largest lexicographic array with at-most K consecutive swapsGiven an array arr[], find the lexicographically largest array that can be obtained by performing at-most k consecutive swaps. Examples : Input : arr[] = {3, 5, 4, 1, 2} k = 3 Output : 5, 4, 3, 2, 1 Explanation : Array given : 3 5 4 1 2 After swap 1 : 5 3 4 1 2 After swap 2 : 5 4 3 1 2 After swap 3
9 min read
Partition into two subsets of lengths K and (N - k) such that the difference of sums is maximumGiven an array of non-negative integers of length N and an integer K. Partition the given array into two subsets of length K and N - K so that the difference between the sum of both subsets is maximum. Examples : Input : arr[] = {8, 4, 5, 2, 10} k = 2 Output : 17 Explanation : Here, we can make firs
7 min read
Greedy algorithm on Operating System
Program for First Fit algorithm in Memory ManagementPrerequisite : Partition Allocation MethodsIn the first fit, the partition is allocated which is first sufficient from the top of Main Memory.Example : Input : blockSize[] = {100, 500, 200, 300, 600}; processSize[] = {212, 417, 112, 426};Output:Process No. Process Size Block no. 1 212 2 2 417 5 3 11
8 min read
Program for Best Fit algorithm in Memory ManagementPrerequisite : Partition allocation methodsBest fit allocates the process to a partition which is the smallest sufficient partition among the free available partitions. Example: Input : blockSize[] = {100, 500, 200, 300, 600}; processSize[] = {212, 417, 112, 426}; Output: Process No. Process Size Bl
8 min read
Program for Worst Fit algorithm in Memory ManagementPrerequisite : Partition allocation methodsWorst Fit allocates a process to the partition which is largest sufficient among the freely available partitions available in the main memory. If a large process comes at a later stage, then memory will not have space to accommodate it. Example: Input : blo
8 min read
Program for Shortest Job First (or SJF) CPU Scheduling | Set 1 (Non- preemptive)The shortest job first (SJF) or shortest job next, is a scheduling policy that selects the waiting process with the smallest execution time to execute next. SJN, also known as Shortest Job Next (SJN), can be preemptive or non-preemptive. Â Characteristics of SJF Scheduling: Shortest Job first has th
13 min read
Job Scheduling with two jobs allowed at a timeGiven a 2d array jobs[][] of order n * 2, where each element jobs[i], contains two integers, representing the start and end time of the job. Your task is to check if it is possible to complete all the jobs, provided that two jobs can be done simultaneously at a particular moment. Note: If a job star
6 min read
Optimal Page Replacement AlgorithmIn operating systems, whenever a new page is referred and not present in memory, page fault occurs, and Operating System replaces one of the existing pages with newly needed page. Different page replacement algorithms suggest different ways to decide which page to replace. The target for all algorit
3 min read
Greedy algorithm on Graph