# Minimum number of days required to complete the work

Last Updated : 24 Feb, 2023

Given N works numbered from 1 to N. Given two arrays, D1[] and D2[] of N elements each. Also, each work number W(i) is assigned days, D1[i] and D2[i] (Such that, D2[i] < D1[i]) either of which can be completed.
Also, it is mentioned that each work has to be completed according to the non-decreasing date of the array D1[].
The task is to find the minimum number of days required to complete the work in non-decreasing order of days in D1[].

Examples

Input :
N = 3
D1[] = {5, 3, 4}
D2[] = {2, 1, 2}
Output : 2
Explanation:
3 works are to be completed. The first value on Line(i) is D1(i) and the second value is D2(i) where D2(i) < D1(i). The smart worker can finish the second work on Day 1 and then both third work and first work in Day 2, thus maintaining the non-decreasing order of D1[], [3 4 5].

Input :
N = 6
D1[] = {3, 3, 4, 4, 5, 5}
D2[] = {1, 2, 1, 2, 4, 4}
Output :

### Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The solution is greedy. The work(i) can be sorted by increasing D1[i], breaking the ties by increasing D2[i]. If we consider the works in this order, we can try to finish the works as early as possible. First of all complete the first work on D2[1]. Move to the second work. If we can complete it on day D2[2] such that (D2[1]<=D2[2]), do it. Otherwise, do the work on day D[2]. Repeat the process until we complete the N-th work, keeping the day of the latest work.

Below is the implementation of the above approach.

## C++

 `// C++ program to find the minimum` `// number days required`   `#include ` `using` `namespace` `std;` `#define inf INT_MAX`   `// Function to find the minimum` `// number days required` `int` `minimumDays(``int` `N, ``int` `D1[], ``int` `D2[])` `{` `    ``// initialising ans to least value possible` `    ``int` `ans = -inf;`   `    ``// vector to store the pair of D1(i) and D2(i)` `    ``vector > vect;`   `    ``for` `(``int` `i = 0; i < N; i++)` `        ``vect.push_back(make_pair(D1[i], D2[i]));`   `    ``// sort by first i.e D(i)` `    ``sort(vect.begin(), vect.end());`   `    ``// Calculate the minimum possible days` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``if` `(vect[i].second >= ans)` `            ``ans = vect[i].second;` `        ``else` `            ``ans = vect[i].first;` `    ``}`   `    ``// return the answer` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Number of works` `    ``int` `N = 3;`   `    ``// D1[i]` `    ``int` `D1[] = { 6, 5, 4 };`   `    ``// D2[i]` `    ``int` `D2[] = { 1, 2, 3 };`   `    ``cout << minimumDays(N, D1, D2);`   `    ``return` `0;` `}`

## Java

 `// Java program to find the minimum` `// number days required` `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;`   `// pair class for number of days` `class` `Pair {` `    ``int` `x, y;`   `    ``Pair(``int` `a, ``int` `b)` `    ``{` `        ``this``.x = a;` `        ``this``.y = b;` `    ``}` `}`   `class` `GFG {` `    ``static` `int` `inf = Integer.MIN_VALUE;`   `    ``// Function to find the minimum` `    ``// number days required` `    ``public` `static` `int` `minimumDays(``int` `N, ``int` `D1[], ``int` `D2[])` `    ``{` `        ``// initialising ans to` `        ``// least value possible` `        ``int` `ans = -inf;`   `        ``ArrayList list = ``new` `ArrayList();`   `        ``for` `(``int` `i = ``0``; i < N; i++)` `            ``list.add(``new` `Pair(D1[i], D2[i]));`   `        ``// sort by first i.e D(i)` `        ``Collections.sort(list, ``new` `Comparator() {` `            ``@Override` `public` `int` `compare(Pair p1, Pair p2)` `            ``{` `                ``return` `p1.x - p2.x;` `            ``}` `        ``});`   `        ``// Calculate the minimum possible days` `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``if` `(list.get(i).y >= ans)` `                ``ans = list.get(i).y;` `            ``else` `                ``ans = list.get(i).x;` `        ``}`   `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Number of works` `        ``int` `N = ``3``;`   `        ``// D1[i]` `        ``int` `D1[] = ``new` `int``[] { ``6``, ``5``, ``4` `};`   `        ``// D2[i]` `        ``int` `D2[] = ``new` `int``[] { ``1``, ``2``, ``3` `};`   `        ``System.out.print(minimumDays(N, D1, D2));` `    ``}` `}`   `// This code is contributed by Kirti_Mangal`

## Javascript

 ``

## Python3

 `def` `minDaysWork(n, day1, day2):` `    ``ans ``=` `0`   `    ``# List to store the pair of day1(i) and day2(i)` `    ``combined ``=` `[[] ``for` `i ``in` `range``(n)]`   `    ``for` `i ``in` `range``(``len``(day1)):` `        ``combined[i] ``=` `[day1[i], day2[i]]`   `    ``# Sort the array` `    ``combined.sort()` `    ``for` `i ``in` `range``(``len``(day1)):` `        ``if` `(combined[i][``1``] >``=` `ans):` `            ``ans ``=` `combined[i][``1``]` `        ``else``:` `            ``ans ``=` `combined[i][``0``]`   `    ``return` `ans`     `# Driver Code` `# Input taken` `N ``=` `3` `D1 ``=` `[``6``, ``5``, ``4``]` `D2 ``=` `[``1``, ``2``, ``3``]` `print``(minDaysWork(N, D1, D2))`

## C#

 `using` `System;` `using` `System.Collections.Generic;` `using` `System.Linq;`   `// pair class for number of days` `class` `Pair {` `    ``public` `int` `x, y;`   `    ``public` `Pair(``int` `a, ``int` `b) {` `        ``this``.x = a;` `        ``this``.y = b;` `    ``}` `}`   `class` `GFG {` `    ``static` `int` `inf = ``int``.MinValue;`   `    ``// Function to find the minimum` `    ``// number days required` `    ``public` `static` `int` `MinimumDays(``int` `N, ``int``[] D1, ``int``[] D2) {` `        ``// initialising ans to` `        ``// least value possible` `        ``int` `ans = -inf;`   `        ``List list = ``new` `List();`   `        ``for` `(``int` `i = 0; i < N; i++)` `            ``list.Add(``new` `Pair(D1[i], D2[i]));`   `        ``// sort by first i.e D(i)` `        ``list.Sort((p1, p2) => p1.x - p2.x);`   `        ``// Calculate the minimum possible days` `        ``for` `(``int` `i = 0; i < N; i++) {` `            ``if` `(list[i].y >= ans)` `                ``ans = list[i].y;` `            ``else` `                ``ans = list[i].x;` `        ``}`   `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args) {` `        ``// Number of works` `        ``int` `N = 3;`   `        ``// D1[i]` `        ``int``[] D1 = ``new` `int``[] { 6, 5, 4 };`   `        ``// D2[i]` `        ``int``[] D2 = ``new` `int``[] { 1, 2, 3 };`   `        ``Console.Write(MinimumDays(N, D1, D2));` `    ``}` `}`

Output:

`6`

Time Complexity: O(nlogn)
Auxiliary Space: O(n)