Minimum time required to complete exactly K tasks based on given order of task execution
Given a 2D array, arr[][] of size N, each row of which consists of the time required to complete 3 different types of tasks A, B, and C. The row elements arr[i][0], arr[i][1] and arr[i][2] are the time required to complete the ith task of type A, B and C respectively. The task is to find the minimum completion time to complete exactly K tasks from the array based on the following conditions:
- The same type of task will operate at the same time.
- Tasks of type B can be performed only when K tasks of type A have already been completed.
- Tasks of type C can be performed only when K tasks of type B have already been completed.
Examples:
Input: N = 3, K = 2, arr[][] = {{1, 2, 2}, {3, 4, 1}, {3, 1, 2}}
Output: 7
Explanation:
Minimum time required to complete K tasks of type A = min(max(arr[0][0], arr[2][0]), max(arr[0][0], arr[1][0]), max(arr[1][0], arr[2][0])) = min(max(1, 3), max(1, 3), max(3, 3)) 3
Minimum time required to complete K tasks of type B = max(arr[0][1], arr[2][1]) = 2
Therefore, select items 1 and 3 as the K tasks to be completed for minimum time.
Therefore, time to complete K tasks of type C = max(arr[0][2], arr[2][2]) = 2
Therefore, minimum time to complete K(= 2) of all types = 3 + 2 + 2 = 7
Input: N = 3, K = 3, arr[][] = {{2, 4, 5}, {4, 5, 4}, {3, 4, 5}}
Output: 14
Approach: The problem can be solved using Recursion. The idea is to either select the ith row from the given array or not. The following are the recurrence relation.
MinTime(TA, TB, TC, K, i) = min(MinTime(max(arr[i][0], TA), max(arr[i][1], TB), max(arr[i][2], TC), K-1, i-1), MinTime(TA, TB, TC, K, i-1))
MinTime(TA, TB, TC, K, i) Stores the minimum time to complete K tasks.
i stores the position of the ith row of the given array elements.
Base Case: if K == 0:
return TA + TB + TC
if i <= 0:
return Infinite
Follow the steps below to solve the problem:
- Initialize a variable, say X and Y while traversing each row recursively using the above recurrence relation.
- X stores the minimum completion time by selecting the ith row of the given array.
- Y stores the minimum completion time by not selecting the ith row of the given array.
- Find the value of X and Y using the above-mentioned recurrence relation.
- Finally, return the value of min(X, Y) for every row.
Below is the implementation of the above approach:
C++
#include<bits/stdc++.h>
using namespace std;
#define N 3
int MinTime( int arr[][N], int i,
int Ta, int Tb,
int Tc, int K)
{
if (K == 0) {
return Ta + Tb + Tc;
}
if (i == 0)
return INT_MAX;
int X = MinTime(arr, i - 1,
max(Ta, arr[i - 1][0]),
max(Tb, arr[i - 1][1]),
max(Tc, arr[i - 1][2]), K -1);
int Y = MinTime(arr, i - 1,
Ta, Tb, Tc, K);
return min(X, Y);
}
int main()
{
int K = 2;
int n = 3;
int arr[N][N] = {{1, 2, 2} ,
{3, 4, 1} ,
{3, 1, 2}
};
cout<<MinTime(arr, N, 0, 0, 0, K);
return 0;
}
|
Java
import java.util.*;
class GFG{
public static int MinTime( int arr[][], int i,
int Ta, int Tb,
int Tc, int K)
{
if (K == 0 )
{
return Ta + Tb + Tc;
}
if (i == 0 )
return Integer.MAX_VALUE;
int X = MinTime(arr, i - 1 ,
Math.max(Ta, arr[i - 1 ][ 0 ]),
Math.max(Tb, arr[i - 1 ][ 1 ]),
Math.max(Tc, arr[i - 1 ][ 2 ]), K - 1 );
int Y = MinTime(arr, i - 1 , Ta,
Tb, Tc, K);
return Math.min(X, Y);
}
public static void main(String args[])
{
int K = 2 ;
int n = 3 ;
int arr[][] = { { 1 , 2 , 2 },
{ 3 , 4 , 1 },
{ 3 , 1 , 2 } };
System.out.println(MinTime(arr, n, 0 , 0 , 0 , K));
}
}
|
Python3
N = 3
def MinTime(arr, i, Ta, Tb, Tc, K):
if (K = = 0 ):
return Ta + Tb + Tc
if (i = = 0 ):
return 10 * * 9
X = MinTime(arr, i - 1 ,
max (Ta, arr[i - 1 ][ 0 ]),
max (Tb, arr[i - 1 ][ 1 ]),
max (Tc, arr[i - 1 ][ 2 ]), K - 1 )
Y = MinTime(arr, i - 1 ,
Ta, Tb, Tc, K)
return min (X, Y)
if __name__ = = '__main__' :
K = 2
n = 3
arr = [ [ 1 , 2 , 2 ],
[ 3 , 4 , 1 ],
[ 3 , 1 , 2 ] ]
print (MinTime(arr, N, 0 , 0 , 0 , K))
|
C#
using System;
class GFG{
public static int MinTime( int [,]arr, int i,
int Ta, int Tb,
int Tc, int K)
{
if (K == 0)
{
return Ta + Tb + Tc;
}
if (i == 0)
return int .MaxValue;
int X = MinTime(arr, i - 1,
Math.Max(Ta,
arr[i - 1, 0]),
Math.Max(Tb,
arr[i - 1, 1]),
Math.Max(Tc,
arr[i - 1, 2]),
K - 1);
int Y = MinTime(arr, i - 1, Ta,
Tb, Tc, K);
return Math.Min(X, Y);
}
public static void Main(String []args)
{
int K = 2;
int n = 3;
int [,]arr = {{1, 2, 2},
{3, 4, 1},
{3, 1, 2}};
Console.WriteLine(MinTime(arr, n, 0,
0, 0, K));
}
}
|
Javascript
<script>
function Mletime(arr, i, Ta, Tb, Tc, K)
{
if (K == 0)
{
return Ta + Tb + Tc;
}
if (i == 0)
return Number.MAX_VALUE;
let X = Mletime(arr, i - 1,
Math.max(Ta, arr[i - 1][0]),
Math.max(Tb, arr[i - 1][1]),
Math.max(Tc, arr[i - 1][2]), K - 1);
let Y = Mletime(arr, i - 1, Ta,
Tb, Tc, K);
return Math.min(X, Y);
}
K = 2;
let n = 3;
let arr = [ [ 1, 2, 2 ],
[ 3, 4, 1 ],
[ 3, 1, 2 ] ];
document.write(Mletime(arr, n, 0, 0, 0, K));
</script>
|
Time Complexity: O(2N)
Auxiliary Space: O(N)
Approach 2 :-
C++
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
int MinTime(vector<vector< int >>& tasks, int k)
{
if (k == 0)
{
return 0;
}
vector<pair< int , pair< int , int >>> arr;
for ( auto t : tasks)
{
arr.push_back({t[0], {t[1], t[2]}});
}
sort(arr.begin(), arr.end());
int ans = INT_MAX / 2;
for ( int i = k - 1; i < arr.size(); i++)
{
vector<pair< int , int >> pr;
for ( int j = 0; j <= i; j++)
{
pr.push_back(arr[j].second);
}
sort(pr.begin(), pr.end());
priority_queue< int > q;
for ( int j = 0; j < pr.size(); j++)
{
q.push(pr[j].second);
if (q.size() > k)
{
q.pop();
}
if (q.size() == k)
{
ans = min(ans, arr[i].first + q.top() + pr[j].first);
}
}
}
return ans;
}
int main() {
int K = 2;
int n = 3;
vector<vector< int >> arr =
{{1, 2, 2} ,
{3, 4, 1} ,
{3, 1, 2}
};
cout<<MinTime(arr,K)<<endl;
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int MinTime( int [][] tasks, int k)
{
if (k == 0 )
{
return 0 ;
}
ArrayList< int []> arr = new ArrayList<>();
for ( int [] t : tasks)
{
arr.add( new int []{t[ 0 ], t[ 1 ], t[ 2 ]});
}
Collections.sort(arr, (a, b)->a[ 0 ] - b[ 0 ]);
int ans =Integer.MAX_VALUE / 2 ;
for ( int i = k - 1 ; i < arr.size(); i++)
{
ArrayList< int []> pr = new ArrayList<>();
for ( int j = 0 ; j <= i; j++)
{
pr.add( new int []{arr.get(j)[ 1 ],arr.get(j)[ 2 ]});
}
Collections.sort(pr, (a, b)->a[ 0 ] - b[ 0 ]);
PriorityQueue<Integer> q = new PriorityQueue<>();
for ( int j = 0 ; j < pr.size(); j++)
{
q.add(pr.get(j)[ 1 ]);
if (q.size() > k)
{
q.poll();
}
if (q.size() == k)
{
ans = Math.min(ans, arr.get(i)[ 0 ] +
q.peek() + pr.get(j)[ 0 ]);
}
}
}
return ans;
}
public static void main (String[] args)
{
int K = 2 ;
int n = 3 ;
int arr[][] = { { 1 , 2 , 2 },
{ 3 , 4 , 1 },
{ 3 , 1 , 2 } };
System.out.println(MinTime(arr,K));
}
}
|
Python3
import sys
def MinTime(tasks,k):
if (k = = 0 ):
return 0
arr = []
for t in tasks:
arr.append([t[ 0 ], t[ 1 ], t[ 2 ]])
arr.sort()
ans = sys.maxsize / / 2
for i in range (k - 1 , len (arr)):
pr = []
for j in range (i + 1 ):
pr.append([arr[j][ 1 ],arr[j][ 2 ]])
pr.sort()
q = []
for j in range ( len (pr)):
q.append(pr[j][ 1 ])
if ( len (q) > k):
q.pop( 0 )
if ( len (q) = = k):
ans = min (ans, arr[i][ 0 ] + q[ 0 ] + pr[j][ 0 ])
return ans
K = 2
n = 3
arr = [[ 1 , 2 , 2 ], [ 3 , 4 , 1 ], [ 3 , 1 , 2 ]]
print (MinTime(arr, K))
|
C#
using System;
using System.Collections.Generic;
class GFG {
static int MinTime( int [,] tasks, int k)
{
if (k == 0)
{
return 0;
}
List<List< int >> arr = new List<List< int >>();
for ( int i = 0; i < tasks.GetLength(0); i++)
{
arr.Add( new List< int >());
for ( int j = 0; j < tasks.GetLength(1); j++)
{
arr[i].Add(tasks[i,j]);
}
}
int ans = Int32.MaxValue / 2;
for ( int i = k - 1; i < arr.Count; i++)
{
List<List< int >> pr = new List<List< int >>();
for ( int j = 0; j <= i; j++)
{
pr.Add( new List< int >());
pr[j].Add(arr[j][1]);
pr[j].Add(arr[j][2]);
}
List< int > q = new List< int >();
for ( int j = 0; j < pr.Count; j++)
{
q.Add(pr[j][1]);
q.Sort();
q.Reverse();
if (q.Count > k)
{
q.RemoveAt(0);
}
if (q.Count == k)
{
ans = Math.Min(ans, arr[i][0] + q[0] + pr[j][0]) + 1;
}
}
}
return ans;
}
static void Main() {
int K = 2;
int [,] arr = { { 1, 2, 2 },
{ 3, 4, 1 },
{ 3, 1, 2 } };
Console.Write(MinTime(arr,K));
}
}
|
Javascript
<script>
function MinTime(tasks,k)
{
if (k == 0)
{
return 0;
}
let arr = [];
for (let t=0;t< tasks.length;t++)
{
arr.push([tasks[t][0], tasks[t][1], tasks[t][2]]);
}
arr.sort( function (a,b){ return a[0]-b[0];});
let ans =Number.MAX_VALUE / 2;
for (let i = k - 1; i < arr.length; i++)
{
let pr = [];
for (let j = 0; j <= i; j++)
{
pr.push([arr[j][1],arr[j][2]]);
}
pr.sort( function (a,b){ return a[0]-b[0];});
let q = [];
for (let j = 0; j < pr.length; j++)
{
q.push(pr[j][1]);
if (q.length > k)
{
q.shift();
}
if (q.length == k)
{
ans = Math.min(ans, arr[i][0] +
q[0] + pr[j][0]);
}
}
}
return ans;
}
let K = 2;
let n = 3;
let arr=[[ 1, 2, 2 ],
[ 3, 4, 1 ],
[ 3, 1, 2 ]];
document.write(MinTime(arr,K));
</script>
|
Time Complexity :- O(N2logN)
Space Complexity:- O(N)
Last Updated :
09 Mar, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...