Related Articles

# Maximize jobs that can be completed under given constraint

• Last Updated : 22 Feb, 2021

Given an integer N denoting number of jobs and a matrix ranges[] consisting of a range [start day, end day] for each job within which it needs to be completed, the task is to find the maximum possible jobs that can be completed.
Examples:

Input: N = 5, Ranges = {{1, 5}, {1, 5}, {1, 5}, {2, 3}, {2, 3}}
Output:
Explanation: Job 1 on day 1, Job 4 on day 2, Job 5 on day 3, Job 2 on day 4, Job 3 on day 5

Input: N=6, Ranges = {{1, 3}, {1, 3}, {2, 3}, {2, 3}, {1, 4}, {2, 5}}
Output:

Approach: The above problem can be solved using a Priority Queue. Follow the steps below to solve the problems:

• Find the minimum and maximum day in the range of jobs.
• Sort all jobs in increasing order of start day.
• Iterate from the minimum to maximum day, and for every ith day, select the job having least end day which can be completed on that day.
• In order to perform the above step, maintain a Min Heap, and on every ith day, insert the jobs that can be completed on that day, into the Min Heap sorted by end day. If any job can completed on the ith day, consider the one with the lowest end day and increase the count of jobs completed.
• Repeat this process for all the days and finally print the count of jobs completed.

Below is an implementation of the above approach:

## C++

 `// C++ Program to implement the` `// above approach`   `#include ` `using` `namespace` `std;`   `// Function to find maxiumum` `// number of jobs` `int` `find_maximum_jobs(` `    ``int` `N,` `    ``vector > ranges)` `{` `    ``// Min Heap` `    ``priority_queue<``int``, vector<``int``>,` `                   ``greater<``int``> >` `        ``queue;`   `    ``// Sort ranges by start day` `    ``sort(ranges.begin(), ranges.end());`   `    ``// Stores the minimum and maximum` `    ``// day in the ranges` `    ``int` `min_day = ranges.first;` `    ``int` `max_day = 0;`   `    ``for` `(``int` `i = 0; i < N; i++)` `        ``max_day` `            ``= max(max_day,` `                  ``ranges[i].second);`   `    ``int` `index = 0, count_jobs = 0;`   `    ``// Iterating from min_day to max_day` `    ``for` `(``int` `i = min_day; i <= max_day; i++) {`   `        ``// Insert the end day of the jobs` `        ``// which can be completed on` `        ``// i-th day in a priority queue` `        ``while` `(index < ranges.size()` `               ``&& ranges[index].first <= i) {`   `            ``queue.push(ranges[index].second);` `            ``index++;` `        ``}`   `        ``// Pop all jobs whose end day` `        ``// is less than current day` `        ``while` `(!queue.empty()` `               ``&& queue.top() < i)` `            ``queue.pop();`   `        ``// If queue is empty, no job` `        ``// can be completed on` `        ``// the i-th day` `        ``if` `(queue.empty())` `            ``continue``;`   `        ``// Increment the count of` `        ``// jobs completed` `        ``count_jobs++;`   `        ``// Pop the job with` `        ``// least end day` `        ``queue.pop();` `    ``}`   `    ``// Return the jobs` `    ``// on the last day` `    ``return` `count_jobs;` `}`   `// Driver Code` `int` `main()` `{`   `    ``int` `N = 5;` `    ``vector > ranges;` `    ``ranges.push_back({ 1, 5 });` `    ``ranges.push_back({ 1, 5 });` `    ``ranges.push_back({ 1, 5 });` `    ``ranges.push_back({ 2, 3 });` `    ``ranges.push_back({ 2, 3 });`   `    ``cout << find_maximum_jobs(N, ranges);` `}`

## Java

 `// Java Program to implement the ` `// above approach ` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `  ``// Function to find maxiumum ` `  ``// number of jobs ` `  ``static` `int` `find_maximum_jobs(``int` `N, ArrayList> ranges)` `  ``{` `    ``// Min Heap ` `    ``ArrayList queue = ``new` `ArrayList(); ` `    ``// Sort ranges by start day ` `    ``Collections.sort(ranges, ``new` `Comparator>() {    ` `      ``@Override` `      ``public` `int` `compare(ArrayList o1, ArrayList o2) {` `        ``return` `o1.get(``0``).compareTo(o2.get(``0``));` `      ``}               ` `    ``});`   `    ``// Stores the minimum and maximum ` `    ``// day in the ranges ` `    ``int` `min_day = ranges.get(``0``).get(``0``); ` `    ``int` `max_day = ``0``; ` `    ``for` `(``int` `i = ``0``; i < N; i++) ` `      ``max_day = Math.max(max_day, ranges.get(i).get(``1``)); ` `    ``int` `index = ``0``, count_jobs = ``0``; `   `    ``// Iterating from min_day to max_day ` `    ``for` `(``int` `i = min_day; i <= max_day; i++)` `    ``{` `      ``// Insert the end day of the jobs ` `      ``// which can be completed on ` `      ``// i-th day in a priority queue ` `      ``while` `(index < ranges.size() && ranges.get(index).get(``0``) <= i) ` `      ``{ ` `        ``queue.add(ranges.get(index).get(``1``)); ` `        ``index++; ` `      ``}` `      ``Collections.sort(queue);`   `      ``// Pop all jobs whose end day ` `      ``// is less than current day ` `      ``while` `(queue.size() > ``0` `&& queue.get(``0``) < i) ` `        ``queue.remove(``0``); `   `      ``// If queue is empty, no job ` `      ``// can be completed on ` `      ``// the i-th day ` `      ``if` `(queue.size() == ``0``) ` `        ``continue``; ` `      ``// Increment the count of ` `      ``// jobs completed ` `      ``count_jobs++; `   `      ``// Pop the job with ` `      ``// least end day ` `      ``queue.remove(``0``);` `    ``}` `    ``// Return the jobs ` `    ``// on the last day ` `    ``return` `count_jobs; `   `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main (String[] args) {`   `    ``int` `N = ``5``; ` `    ``ArrayList> ranges = ``new` `ArrayList>();` `    ``ranges.add(``new` `ArrayList(Arrays.asList(``1``, ``5``)));` `    ``ranges.add(``new` `ArrayList(Arrays.asList(``1``, ``5``)));` `    ``ranges.add(``new` `ArrayList(Arrays.asList(``1``, ``5``)));` `    ``ranges.add(``new` `ArrayList(Arrays.asList(``2``, ``3``)));` `    ``ranges.add(``new` `ArrayList(Arrays.asList(``2``, ``3``)));` `    ``System.out.println(find_maximum_jobs(N, ranges));` `  ``}` `}` `// This code is contributed by avanitrachhadiya2155`

## Python3

 `# Python3 Program to implement the ` `# above approach `   `# Function to find maxiumum ` `# number of jobs ` `def` `find_maximum_jobs(N, ranges) : `   `    ``# Min Heap ` `    ``queue ``=` `[]` `    `  `    ``# Sort ranges by start day ` `    ``ranges.sort()` `    `  `    ``# Stores the minimum and maximum ` `    ``# day in the ranges ` `    ``min_day ``=` `ranges[``0``][``0``] ` `    ``max_day ``=` `0` `    ``for` `i ``in` `range``(N) :` `      ``max_day ``=` `max``(max_day, ranges[i][``1``]) ` `    ``index, count_jobs ``=` `0``, ``0` `    `  `    ``# Iterating from min_day to max_day ` `    ``for` `i ``in` `range``(min_day, max_day ``+` `1``) : ` `    `  `      ``# Insert the end day of the jobs ` `      ``# which can be completed on ` `      ``# i-th day in a priority queue ` `      ``while` `(index < ``len``(ranges) ``and` `ranges[index][``0``] <``=` `i) :` `      `  `        ``queue.append(ranges[index][``1``]) ` `        ``index ``+``=` `1` `      `  `      ``queue.sort()` `    `  `      ``# Pop all jobs whose end day ` `      ``# is less than current day ` `      ``while` `(``len``(queue) > ``0` `and` `queue[``0``] < i) :` `        ``queue.pop(``0``)` `    `  `      ``# If queue is empty, no job ` `      ``# can be completed on ` `      ``# the i-th day ` `      ``if` `(``len``(queue) ``=``=` `0``) :` `        ``continue` `    `  `      ``# Increment the count of ` `      ``# jobs completed ` `      ``count_jobs ``+``=` `1` `    `  `      ``# Pop the job with ` `      ``# least end day ` `      ``queue.pop(``0``)` `    `  `    ``# Return the jobs ` `    ``# on the last day ` `    ``return` `count_jobs` `    `  `    ``# Driver code` `N ``=` `5` `ranges ``=` `[]` `ranges.append((``1``, ``5``))` `ranges.append((``1``, ``5``))` `ranges.append((``1``, ``5``))` `ranges.append((``2``, ``3``))` `ranges.append((``2``, ``3``))`   `print``(find_maximum_jobs(N, ranges))`   `# This code is contributed by divyeshrabadiya07.`

## C#

 `// C# Program to implement the ` `// above approach ` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG {`   `  ``// Function to find maxiumum ` `  ``// number of jobs ` `  ``static` `int` `find_maximum_jobs(``int` `N, List> ranges) ` `  ``{ ` `    ``// Min Heap ` `    ``List<``int``> queue = ``new` `List<``int``>(); `   `    ``// Sort ranges by start day ` `    ``ranges.Sort(); `   `    ``// Stores the minimum and maximum ` `    ``// day in the ranges ` `    ``int` `min_day = ranges.Item1; ` `    ``int` `max_day = 0; ` `    ``for` `(``int` `i = 0; i < N; i++) ` `      ``max_day = Math.Max(max_day, ranges[i].Item2); ` `    ``int` `index = 0, count_jobs = 0; `   `    ``// Iterating from min_day to max_day ` `    ``for` `(``int` `i = min_day; i <= max_day; i++) ` `    ``{ `   `      ``// Insert the end day of the jobs ` `      ``// which can be completed on ` `      ``// i-th day in a priority queue ` `      ``while` `(index < ranges.Count && ranges[index].Item1 <= i) ` `      ``{ ` `        ``queue.Add(ranges[index].Item2); ` `        ``index++; ` `      ``}` `      ``queue.Sort();`   `      ``// Pop all jobs whose end day ` `      ``// is less than current day ` `      ``while` `(queue.Count > 0 && queue < i) ` `        ``queue.RemoveAt(0); `   `      ``// If queue is empty, no job ` `      ``// can be completed on ` `      ``// the i-th day ` `      ``if` `(queue.Count == 0) ` `        ``continue``; `   `      ``// Increment the count of ` `      ``// jobs completed ` `      ``count_jobs++; `   `      ``// Pop the job with ` `      ``// least end day ` `      ``queue.RemoveAt(0); ` `    ``} `   `    ``// Return the jobs ` `    ``// on the last day ` `    ``return` `count_jobs; ` `  ``} `   `  ``// Driver code` `  ``static` `void` `Main()` `  ``{` `    ``int` `N = 5; ` `    ``List> ranges = ``new` `List>(); ` `    ``ranges.Add(``new` `Tuple<``int``,``int``>(1, 5));` `    ``ranges.Add(``new` `Tuple<``int``,``int``>(1, 5));` `    ``ranges.Add(``new` `Tuple<``int``,``int``>(1, 5));` `    ``ranges.Add(``new` `Tuple<``int``,``int``>(2, 3));` `    ``ranges.Add(``new` `Tuple<``int``,``int``>(2, 3));`   `    ``Console.Write(find_maximum_jobs(N, ranges)); ` `  ``}` `}`   `// This code is contributed by divyesh072019.`

Output:

`5`

Time Complexity: O(Xlog(N)), where X is the difference between maximum and minimum day and N is the number of jobs.
Auxiliary Space: O(N2) My Personal Notes arrow_drop_up
Recommended Articles
Page :