# Job Scheduling with two jobs allowed at a time

We are given N jobs, and their starting and ending times. We can do two jobs simultaneously at a particular moment. If one job ends at the same moment some other show starts then we can’t do them. We need to check if it is possible to complete all the jobs or not.
Examples:

```Input :  Start and End times of Jobs
1 2
2 3
4 5
Output : Yes
By the time third job starts, both jobs
are finished. So we can schedule third
job.

Input : Start and End times of Jobs
1 5
2 4
2 6
1 7
Output : No
All 4 jobs needs to be scheduled at time
3 which is not possible.```

We first sort the jobs according to their starting time. Then we start two jobs simultaneously and check if the starting time of third job and so on is greater than the ending time of and of the previous two jobs.
The implementation the above idea is given below.

## C++

 `// CPP program to check if all jobs can be scheduled``// if two jobs are allowed at a time.``#include ``using` `namespace` `std;` `bool` `checkJobs(``int` `startin[], ``int` `endin[], ``int` `n)``{``    ``// making a pair of starting and ending time of job``    ``vector > a;``    ``for` `(``int` `i = 0; i < n; i++)``        ``a.push_back(make_pair(startin[i], endin[i]));` `    ``// sorting according to starting time of job``    ``sort(a.begin(), a.end());` `    ``// starting first and second job simultaneously``    ``long` `long` `tv1 = a[0].second, tv2 = a[1].second;` `    ``for` `(``int` `i = 2; i < n; i++) {``        ` `        ``// Checking if starting time of next new job``        ``// is greater than ending time of currently``        ``// scheduled first job``        ``if` `(a[i].first >= tv1)``        ``{``            ``tv1 = tv2;``            ``tv2 = a[i].second;``        ``}``        ` `        ``// Checking if starting time of next new job``        ``// is greater than ending time of currently``        ``// scheduled second job``        ``else` `if` `(a[i].first >= tv2)``            ``tv2 = a[i].second;` `        ``else``            ``return` `false``;``    ``}``    ``return` `true``;``}` `// Driver code``int` `main()``{``    ``int` `startin[] = { 1, 2, 4 }; ``// starting time of jobs``    ``int` `endin[] = { 2, 3, 5 }; ``// ending times of jobs``    ``int` `n = ``sizeof``(startin) / ``sizeof``(startin[0]);``    ``cout << checkJobs(startin, endin, n);``    ``return` `0;``}`

## Java

 `// Java program to check if all jobs can be scheduled``// if two jobs are allowed at a time.` `import` `java.util.*;` `// Generic Pair class definition``class` `Pair {` `  ``// Data members``  ``private` `T key;``  ``private` `U value;` `  ``// Constructor``  ``public` `Pair(T key, U value)``  ``{``    ``this``.key = key;``    ``this``.value = value;``  ``}` `  ``// Getters``  ``public` `T getKey() { ``return` `key; }` `  ``public` `U getValue() { ``return` `value; }``}` `class` `GFG {` `  ``public` `static` `boolean` `checkJobs(``int``[] startin,``                                  ``int``[] endin, ``int` `n)``  ``{``    ``// making a pair of starting and ending time of job``    ``List > a = ``new` `ArrayList<>();``    ``for` `(``int` `i = ``0``; i < n; i++)``      ``a.add(``new` `Pair(startin[i],``                                       ``endin[i]));` `    ``// sorting according to starting time of job``    ``Collections.sort(``      ``a, ``new` `Comparator >() {``        ``public` `int` `compare(Pair a,``                           ``Pair b)``        ``{``          ``return` `a.getKey().compareTo(b.getKey());``        ``}``      ``});` `    ``// starting key and value job simultaneously``    ``long` `tv1 = a.get(``0``).getValue(),``    ``tv2 = a.get(``1``).getValue();` `    ``for` `(``int` `i = ``2``; i < n; i++) {``      ``// Checking if starting time of next new job``      ``// is greater than ending time of currently``      ``// scheduled key job``      ``if` `(a.get(i).getKey() >= tv1) {``        ``tv1 = tv2;``        ``tv2 = a.get(i).getValue();``      ``}``      ``// Checking if starting time of next new job``      ``// is greater than ending time of currently``      ``// scheduled value job``      ``else` `if` `(a.get(i).getKey() >= tv2)``        ``tv2 = a.get(i).getValue();` `      ``else``        ``return` `false``;``    ``}``    ``return` `true``;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int``[] startin``      ``= { ``1``, ``2``, ``4` `}; ``// starting time of jobs``    ``int``[] endin = { ``2``, ``3``, ``5` `}; ``// ending times of jobs``    ``int` `n = startin.length;``    ``System.out.println(checkJobs(startin, endin, n));``  ``}``}`

## Python3

## C#

 `using` `System;` `class` `Program``{``    ``static` `bool` `CheckJobs(``int``[] startin, ``int``[] endin, ``int` `n)``    ``{``        ``// making a pair of starting and ending time of job``        ``(``int``, ``int``)[] a = ``new` `(``int``, ``int``)[n];``        ``for` `(``int` `i = 0; i < n; i++)``            ``a[i] = (startin[i], endin[i]);` `        ``// sorting according to starting time of job``        ``Array.Sort(a);` `        ``// starting first and second job simultaneously``        ``long` `tv1 = a[0].Item2, tv2 = a[1].Item2;` `        ``for` `(``int` `i = 2; i < n; i++)``        ``{``            ``// Checking if starting time of next new job``            ``// is greater than ending time of currently``            ``// scheduled first job``            ``if` `(a[i].Item1 >= tv1)``            ``{``                ``tv1 = tv2;``                ``tv2 = a[i].Item2;``            ``}``            ``// Checking if starting time of next new job``            ``// is greater than ending time of currently``            ``// scheduled second job``            ``else` `if` `(a[i].Item1 >= tv2)``            ``{``                ``tv2 = a[i].Item2;``            ``}``            ``else``            ``{``                ``return` `false``;``            ``}``        ``}``        ``return` `true``;``    ``}` `    ``static` `void` `Main()``    ``{``        ``int``[] startin = { 1, 2, 4 }; ``// starting time of jobs``        ``int``[] endin = { 2, 3, 5 }; ``// ending times of jobs``        ``int` `n = startin.Length;``        ``Console.WriteLine(CheckJobs(startin, endin, n));``    ``}``}`

## Javascript

 `// JS code``function` `checkJobs(startin, endin, n) {``    ``let a = [];``    ``for` `(let i = 0; i < n; i++) {``        ``a.push([startin[i], endin[i]]);``    ``}``    ``a.sort((a, b) => a[0] - b[0]);``    ``let tv1 = a[0][1], tv2 = a[1][1];``    ``for` `(let i = 2; i < n; i++) {``        ``if` `(a[i][0] >= tv1) {``            ``tv1 = tv2;``            ``tv2 = a[i][1];``        ``}``        ``else` `if` `(a[i][0] >= tv2) {``            ``tv2 = a[i][1];``        ``}``        ``else` `{``            ``return` `false``;``        ``}``    ``}``    ``return` `true``;``}` `let startin = [1, 2, 4];``let endin = [2, 3, 5];``let n = startin.length;``console.log(checkJobs(startin, endin, n));`

Output
`1`

Time Complexity: O(n log n), where n is the number of jobs. The sorting operation on the job array takes O(n log n) time, and the for loop iterates over the array once, which takes O(n) time. Hence, the overall time complexity is O(n log n).

Auxiliary Space: O(1). The algorithm uses constant extra space for storing temporary variables.

An alternate solution is to find maximum number of jobs that needs to be scheduled at any time. If this count is more than 2, return false. Else return true.

Previous
Next