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.
// CPP program to check if all jobs can be scheduled // if two jobs are allowed at a time. #include <bits/stdc++.h> using namespace std;
bool checkJobs( int startin[], int endin[], int n)
{ // making a pair of starting and ending time of job
vector<pair< int , int > > 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 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<T, U> {
// 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<Pair<Integer, Integer> > a = new ArrayList<>();
for ( int i = 0 ; i < n; i++)
a.add( new Pair<Integer, Integer>(startin[i],
endin[i]));
// sorting according to starting time of job
Collections.sort(
a, new Comparator<Pair<Integer, Integer> >() {
public int compare(Pair<Integer, Integer> a,
Pair<Integer, Integer> 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));
}
} |
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));
}
} |
// 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)); |
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.