Maximizar la diferencia restante entre dos pares en un Array dado

Dada una array arr[] de tamaño N, la tarea es encontrar 4 índices i, j, k, l tales que 0 <= i, j, k, l < N y el valor de arr[i]%arr[j ] – arr[k]%arr[l] es el máximo. Imprime la diferencia máxima. Si no existe, imprima -1.

Ejemplos:

Entrada: N=8, arr[] = {1, 2, 4, 6, 8, 3, 5, 7}
Salida: 7
Explicación: Elegir los elementos 1, 2, 7, 8 y 2%1 – 7%8 da el máximo resultado posible.

Entrada: N=3, arr[] = {1, 50, 101}
Salida: -1
Explicación: Dado que solo hay 3 elementos, no hay una respuesta posible.

Enfoque ingenuo: la idea de fuerza bruta sería verificar todas las combinaciones posibles y luego encontrar la diferencia máxima.
Complejidad de Tiempo: O(N ⁴ )
Espacio Auxiliar: O(1)

Enfoque eficiente: la idea se basa en la observación de que al ordenar la array en orden ascendente , elija el primer par del lado izquierdo, es decir, los 2 valores mínimos y el segundo par del lado derecho, es decir, los 2 valores máximos. da la respuesta. Además, arr[i+1]%arr[i] siempre es menor que arr[i]%arr[i+1]. Entonces, minimice el valor del primer par y maximice el valor del segundo par. Siga los pasos a continuación para resolver el problema:

• Si el tamaño de la array es inferior a 4, devuelva -1.
• Ordene la array arr[] en orden ascendente .
• Inicialice la variable primero como arr[1]%arr[0] y segundo como arr[N-2]%arr[N-1].
• Después de realizar los pasos anteriores, imprima el valor de segundo primero como respuesta.

A continuación se muestra la implementación del enfoque anterior.

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the required
// maximum difference
void maxProductDifference(vector<int>& arr)
{
 
    // Base Case
    if (arr.size() < 4) {
        cout << "-1\n";
        return;
    }
 
    // Sort the array
    sort(arr.begin(), arr.end());
 
    // First pair
    int first = arr[1] % arr[0];
 
    // Second pair
    int second = arr[arr.size() - 2]
                 % arr[arr.size() - 1];
 
    // Print the result
    cout << second - first;
 
    return;
}
 
// Driver Code
int main()
{
    vector<int> arr = { 1, 2, 4, 6, 8, 3, 5, 7 };
 
    maxProductDifference(arr);
 
    return 0;
}

// Java program for the above approach
import java.io.*;
import java.util.Arrays;
 
class GFG
{
   
    // Function to find the required
    // maximum difference
    static void maxProductDifference(int[] arr)
    {
 
        // Base Case
        if (arr.length < 4) {
            System.out.println("-1");
            return;
        }
 
        // Sort the array
        Arrays.sort(arr);
 
        // First pair
        int first = arr[1] % arr[0];
 
        // Second pair
        int second
            = arr[arr.length - 2] % arr[arr.length - 1];
 
        // Print the result
        System.out.println(second - first);
 
        return;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int[] arr = { 1, 2, 4, 6, 8, 3, 5, 7 };
 
        maxProductDifference(arr);
    }
}
 
// This code is contributed by Potta Lokesh

# python program for the above approach
 
# Function to find the required
# maximum difference
 
 
def maxProductDifference(arr):
 
    # Base Case
    if (len(arr) < 4):
        print("-1")
        return
 
        # Sort the array
 
    arr.sort()
 
    # First pair
    first = arr[1] % arr[0]
 
    # Second pair
 
    second = arr[len(arr) - 2] % arr[len(arr) - 1]
 
    # Print the result
    print(second - first)
 
 
# Driver Code
if __name__ == "__main__":
 
    arr = [1, 2, 4, 6, 8, 3, 5, 7]
 
    maxProductDifference(arr)
 
    # This code is contributed by rakeshsahni

// C# program for the above approach
using System;
 
public class GFG
{
   
    // Function to find the required
    // maximum difference
    static void maxProductDifference(int[] arr)
    {
 
        // Base Case
        if (arr.Length < 4) {
            Console.WriteLine("-1");
            return;
        }
 
        // Sort the array
        Array.Sort(arr);
 
        // First pair
        int first = arr[1] % arr[0];
 
        // Second pair
        int second
            = arr[arr.Length - 2] % arr[arr.Length - 1];
 
        // Print the result
        Console.WriteLine(second - first);
 
        return;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int[] arr = { 1, 2, 4, 6, 8, 3, 5, 7 };
 
        maxProductDifference(arr);
    }
}
 
// This code is contributed by shikhasingrajput

<script>
// Javascript program for the above approach
 
// Function to find the required
// maximum difference
function maxProductDifference(arr)
{
 
  // Base Case
  if (arr.length < 4) {
    document.write("-1<br>");
    return;
  }
 
  // Sort the array
  arr.sort();
 
  // First pair
  let first = arr[1] % arr[0];
 
  // Second pair
  let second = arr[arr.length - 2] % arr[arr.length - 1];
 
  // Print the result
  document.write(second - first);
 
  return;
}
 
// Driver Code
let arr = [1, 2, 4, 6, 8, 3, 5, 7];
maxProductDifference(arr);
 
// This code is contributed by gfgking.
</script>

7

Complejidad de tiempo: O(N*log(N))
Espacio auxiliar: O(1)