Número mínimo de días requeridos para completar el trabajo.

Dadas N obras numeradas del 1 al N. Dadas dos arrays, D1[] y D2[] de N elementos cada una. Además, a cada número de trabajo W(i) se le asignan días, D1[i] y D2[i] ( Tal que, D2[i] < D1[i] ) cualquiera de los cuales puede completarse. 
Además, se menciona que cada trabajo debe completarse de acuerdo con la fecha no decreciente de la array D1[] .
La tarea es encontrar el número mínimo de días necesarios para completar el trabajo en orden de días no decreciente en D1[].

Ejemplos : 

Entrada: 
N = 3 
D1[] = {5, 3, 4} 
D2[] = {2, 1, 2} 
Salida: 2
Explicación: 
3 obras deben completarse. El primer valor en Line(i) es D1(i) y el segundo valor es D2(i) donde D2(i) < D1(i). El trabajador inteligente puede terminar el segundo trabajo en el Día 1 y luego tanto el tercer trabajo como el primero en el Día 2, manteniendo así el orden no decreciente de D1[], [3 4 5].

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

Recomendado: pruebe su enfoque en {IDE} primero, antes de pasar a la solución.

Enfoque: La solución es codicioso. El trabajo (i) se puede ordenar aumentando D1[i], rompiendo los empates aumentando D2[i]. Si consideramos las obras en este orden, podemos intentar terminar las obras lo antes posible. En primer lugar, complete el primer trabajo en D2[1]. Pasa al segundo trabajo. Si podemos completarlo en el día D2[2] tal que (D2[1]<=D2[2]), hágalo. De lo contrario, haga el trabajo el día D[2]. Repetir el proceso hasta completar el N-ésimo trabajo, manteniendo el día del último trabajo. 
A continuación se muestra la implementación del enfoque anterior. 

// C++ program to find the minimum
// number days required
 
#include <bits/stdc++.h>
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<pair<int, int> > 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 program to find the minimum
// number days required
import java.util.*;
import java.lang.*;
import java.io.*;
 
// 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<Pair>
              list = new ArrayList<Pair>();
     
    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<Pair>()
    {
        @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

<script>
  
// Javascript program to find the minimum
// number days required
 
// Function to find the minimum
// number days required
function minimumDays(N, D1, D2)
{
    // initialising ans to least value possible
    var ans = -1000000000;
 
    // vector to store the pair of D1(i) and D2(i)
    var vect = [];
 
    for (var i = 0; i < N; i++)
        vect.push([D1[i], D2[i]]);
     
 
    // sort by first i.e D(i)
    vect.sort((a,b)=>a-b)
 
    // Calculate the minimum possible days
    for (var i = 0; i < N; i++) {
        if (vect[i][1] >= ans)
            ans = vect[i][1];
        else
            ans = vect[i][0];
    }
 
    // return the answer
    return ans;
}
 
// Driver Code
// Number of works
var N = 3;
 
// D1[i]
var D1 = [6, 5, 4 ];
 
// D2[i]
var D2 = [1, 2, 3 ];
document.write( minimumDays(N, D1, D2));
 
 
</script>

6