GFG App
Open App
Browser
Continue

# Check if CPU will process given requests successfully or not

Given an integer capacity the maximum number of the processes handled by a CPU at any given time and a 2-D array request[][] is given, each request has three parameters:

• a number of processes requiring CPU,
• start time,
• finish time.

The task is to check if the CPU will entertain all the requests successfully or not. If yes return TRUE else FALSE. The start time of the CPU is 0 initially.

Examples:

Input: request[][] = {{2, 1, 5}, {3, 3, 7}}, capacity = 4
Output: false
Explanation: First request says that 2 processes need CPU at time=1 and will release back at time=5. CPU servicing 2 process at time=1. Second request comes and asks CPU to service 3 more processes at time=3 to time=7. At time=3, CPU is busy with request-1 and hence can’t service request-2. So, return FALSE.

Input: request[][] = {{2, 1, 5}, {3, 3, 7}}, capacity = 5
Output: true

Approach: The idea is to keep track of CPU utilization at every point in time. If CPU utilization crosses its maximum limit then, stop the program with the FALSE return. Let curr be the number of processes currently in the CPU. So initially curr = 0 for request[i]

• at fromi time curr will be increased by numProcessi
• at toi time curr will be decreased by numProcessi

at any point of time, if curr>capacity, just return false. Follow the steps below to solve the problem:

• Initialize a vector of pair v[].
• Iterate over the range [0, request.size()) using the variable i and perform the following tasks:
• Push the pair {request[i][1], request[i][0]} to the vector v[].
• Push the pair {request[i][2], -request[i][0]} to the vector v[].
• Sort the vector v[].
• Initialize the variable curr as 0.
• Iterate over the range [0, v.size()) using the variable i and perform the following tasks:
• Add v[i].second to the variable curr.
• If curr is greater than capacity, then return false.
• After performing the above steps, return true as the answer.

Below is the implementation of the above approach:

## C++

 `// C++ Program for the above approach` `#include ` `#include ` `#include ` `using` `namespace` `std;`   `// Function to check whether all requests` `// can be fulfilled or not` `bool` `cpuAllocation(vector >& request,` `                   ``int` `capacity)` `{` `    ``vector > v;`   `    ``for` `(``int` `i = 0; i < request.size(); i++) {`   `        ``// Pushing fromi,` `        ``// numPassengersi` `        ``v.push_back({ request[i][1],` `                      ``request[i][0] });`   `        ``// Pushing toi,` `        ``// -numPassengersi` `        ``v.push_back({ request[i][2],` `                      ``-request[i][0] });` `    ``}`   `    ``sort(v.begin(), v.end());`   `    ``int` `curr = 0;`   `    ``for` `(``int` `i = 0; i < v.size(); i++) {` `        ``curr += v[i].second;`   `        ``if` `(curr > capacity)` `            ``return` `false``;` `    ``}`   `    ``return` `true``;` `}`   `// Driver Code` `int` `main()` `{`   `    ``vector > request{ { 2, 1, 5 },` `                                  ``{ 3, 3, 7 } };` `    ``int` `capacity = 5;` `    ``bool` `res = cpuAllocation(request, capacity);` `    ``if` `(res == ``true``)` `        ``cout << ``"TRUE"``;` `    ``else` `        ``cout << ``"FALSE"``;`   `    ``return` `0;` `}`

## Java

 `// Java Program for the above approach`   `import` `java.util.*;`   `class` `GFG {` `  ``static` `class` `pair ``implements` `Comparable {` `    ``int` `first, second;`   `    ``pair(``int` `s, ``int` `e) {` `      ``first = s;` `      ``second = e;` `    ``}`   `    ``// Function to sort the vector elements` `    ``// ascending for first element` `    ``// and if first element equal` `    ``// then descending for second element` `    ``public` `int` `compareTo(pair a) {`   `      ``return` `this``.first > a.first ? ``1` `: ``0``;` `    ``}`   `  ``}`   `  ``// Function to check whether all requests` `  ``// can be fulfilled or not` `  ``static` `boolean` `cpuAllocation(``int``[][] request, ``int` `capacity) {` `    ``Vector v = ``new` `Vector<>();`   `    ``for` `(``int` `i = ``0``; i < request.length; i++) {`   `      ``// Pushing fromi,` `      ``// numPassengersi` `      ``v.add(``new` `pair(request[i][``1``], request[i][``0``]));`   `      ``// Pushing toi,` `      ``// -numPassengersi` `      ``v.add(``new` `pair(request[i][``2``], -request[i][``0``]));` `    ``}`   `    ``Collections.sort(v);`   `    ``int` `curr = ``0``;`   `    ``for` `(``int` `i = ``0``; i < v.size(); i++) {` `      ``curr += v.get(i).second;`   `      ``if` `(curr > capacity)` `        ``return` `false``;` `    ``}`   `    ``return` `true``;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args) {`   `    ``int``[][] request = { { ``2``, ``1``, ``5` `}, { ``3``, ``3``, ``7` `} };` `    ``int` `capacity = ``5``;` `    ``boolean` `res = cpuAllocation(request, capacity);` `    ``if` `(res == ``true``)` `      ``System.out.print(``"TRUE"``);` `    ``else` `      ``System.out.print(``"FALSE"``);`   `  ``}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python Program for the above approach` `class` `pair:` `    ``def` `__init__(``self``, s, e):` `        ``self``.first ``=` `s` `        ``self``.second ``=` `e`   `# Function to check whether all requests` `# can be fulfilled or not` `def` `cpuAllocation(request, capacity):` `    ``v ``=` `[]`   `    ``for` `i ``in` `range``(``len``(request)):` `        ``# Pushing fromi,` `        ``# numPassengersi` `        ``v.append(pair(request[i][``1``], request[i][``0``]))`   `        ``# Pushing toi,` `        ``# -numPassengersi` `        ``v.append(pair(request[i][``2``], ``-``request[i][``0``]))`   `    ``v.sort(key``=``lambda` `x: (x.first, ``-``x.second))`   `    ``curr ``=` `0`   `    ``for` `i ``in` `range``(``len``(v)):` `        ``curr ``+``=` `v[i].second`   `        ``if` `(curr > capacity):` `            ``return` `False`   `    ``return` `True`   `# Driver Code` `request ``=` `[[``2``, ``1``, ``5``], [``3``, ``3``, ``7``]]` `capacity ``=` `5` `res ``=` `cpuAllocation(request, capacity)` `if` `(res ``=``=` `True``):` `    ``print``(``"TRUE"``)` `else``:` `    ``print``(``"FALSE"``)`   `# This code is contributed by Lovely Jain`

## C#

 `// C# Program for the above approach`   `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG {` `  ``class` `pair : IComparable` `  ``{` `    ``public` `int` `first, second;` `    ``public` `pair(``int` `first, ``int` `second) ` `    ``{` `      ``this``.first = first;` `      ``this``.second = second;` `    ``}` `    ``public` `int` `CompareTo(pair p)` `    ``{` `      ``return` `this``.first > p.first ? 1 : 0;` `    ``}` `  ``}`   `  ``// Function to check whether all requests` `  ``// can be fulfilled or not` `  ``static` `bool` `cpuAllocation(``int``[,] request, ``int` `capacity) {` `    ``List v = ``new` `List();`   `    ``for` `(``int` `i = 0; i < request.GetLength(0); i++) {`   `      ``// Pushing fromi,` `      ``// numPassengersi` `      ``v.Add(``new` `pair(request[i,1], request[i,0]));`   `      ``// Pushing toi,` `      ``// -numPassengersi` `      ``v.Add(``new` `pair(request[i,2], -request[i,0]));` `    ``}`   `    ``v.Sort();`   `    ``int` `curr = 0;`   `    ``for` `(``int` `i = 0; i < v.Count; i++) {` `      ``curr += v[i].second;`   `      ``if` `(curr > capacity)` `        ``return` `false``;` `    ``}`   `    ``return` `true``;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(String[] args) ` `  ``{`   `    ``int``[,] request = { { 2, 1, 5 }, { 3, 3, 7 } };` `    ``int` `capacity = 5;` `    ``bool` `res = cpuAllocation(request, capacity);` `    ``if` `(res == ``true``)` `      ``Console.Write(``"TRUE"``);` `    ``else` `      ``Console.Write(``"FALSE"``);`   `  ``}` `}`   `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output

`TRUE`

Time Complexity: O(N*log(N))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up