Encuentre el valor mínimo de la expresión eligiendo K elementos de una array dada

Dada una array de enteros arr de tamaño N , la tarea es encontrar el mínimo posible de la expresión eligiendo exactamente K(≤ N) enteros de la array dada arr . Digamos que si los elementos elegidos se almacenan en el arreglo B (B ₁ , B ₂ , B ₃ …..B _k ) entonces el valor de la expresión:
$x = \sum_{i=1}^k\sum_{j=1}^k(B_i - B_j)^{2}$

Ejemplos:

Entrada: arr[] = {2, 0, 9, 5}, k = 2
Salida: 8
Digamos que los elementos elegidos son {2, 0}, luego x = 8, que es el mínimo posible

Entrada: arr[] = {4, 21, 5, 3, 8}, k = 3
Salida: 200

Enfoque:
La expresión anterior se puede simplificar como:

$\sum_{i=1}^k\sum_{j=1}^k(B_i^2 + B_j^2 - 2*B_i*B_j)$
$\sum_{i=1}^k\sum_{j=1}^k{B_i^2} + \sum_{i=1}^k\sum_{j=1}^k{B_j^2} - 2\sum_{i=1}^k\sum_{j=1}^k{B_i*B_j}$
$k*\sum_{i=1}^k{B_i^2} + k*\sum_{i=1}^k{B_j^2} - 2\sum_{i=1}^k{B_i}*\sum_{j=1}^k{B_j}$
$2*k*\sum_{i=1}^k{B_i^2} - 2\sum_{i=1}^k{B_i^2}$
$(2*k-2)*\sum_{i=1}^k{B_i^2}$

Entonces, todo lo que tenemos que hacer es seleccionar los k elementos más pequeños de la array y resolver la expresión.

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

C++

// CPP program to find the minimum possible of the expression
// by choosing exactly K(? N) integers form given array arr
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum possible of the expression
// by choosing exactly K(? N) integers form given array arr
int minimumValue(int arr[], int n, int k)
{
 
    // Sorting the array for least k element selection
    sort(arr, arr + n);
 
    int answer = 0;
 
    // Select first k elements from sorted array
    for (int i = 0; i < k; i++)
        answer += arr[i] * arr[i];
 
    // Return value of solved expression
    return answer * (2 * k - 2);
}
 
// Driver code
int main()
{
    int arr[] = { 4, 21, 5, 3, 8 }, k = 3;
     
    int n = sizeof(arr) / sizeof(arr[0]);
     
    // Function call
    cout << minimumValue(arr, n, k);
     
    return 0;
}

Java

// JAVA program to find the minimum possible of the expression
// by choosing exactly K(? N) integers form given array arr 
import java.util.*;
 
class GFG{
 
// Function to find the minimum possible of the expression
// by choosing exactly K(? N) integers form given array arr
static int minimumValue(int arr[], int n, int k)
{
 
    // Sorting the array for least k element selection
    Arrays.sort(arr);
 
    int answer = 0;
 
    // Select first k elements from sorted array
    for (int i = 0; i < k; i++)
        answer += arr[i] * arr[i];
 
    // Return value of solved expression
    return answer * (2 * k - 2);
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 4, 21, 5, 3, 8 }, k = 3;
     
    int n = arr.length;
     
    // Function call
    System.out.print(minimumValue(arr, n, k));    
}
}
 
// This code is contributed by Rajput-Ji

Python3

# Python program to find the minimum
# possible of the expression by choosing
# exactly K(? N) integers form given array arr
 
# Function to find the minimum
# possible of the expression by
# choosing exactly K(? N) integers
# form given array arr
def minimumValue(arr, n, k):
 
    # Sorting the array for least k element selection
    arr.sort();
 
    answer = 0;
 
    # Select first k elements from sorted array
    for i in range(k):
        answer += arr[i] * arr[i];
 
    # Return value of solved expression
    return answer * (2 * k - 2);
 
# Driver code
if __name__ == '__main__':
    arr = [ 4, 21, 5, 3, 8 ];
    k = 3;
 
    n = len(arr);
 
    # Function call
    print(minimumValue(arr, n, k));
 
# This code is contributed by Rajput-Ji

C#

// C# program to find the minimum possible of the expression
// by choosing exactly K(? N) integers form given array arr 
using System;
 
class GFG{
  
// Function to find the minimum possible of the expression
// by choosing exactly K(? N) integers form given array arr
static int minimumValue(int []arr, int n, int k)
{
  
    // Sorting the array for least k element selection
    Array.Sort(arr);
  
    int answer = 0;
  
    // Select first k elements from sorted array
    for (int i = 0; i < k; i++)
        answer += arr[i] * arr[i];
  
    // Return value of solved expression
    return answer * (2 * k - 2);
}
  
// Driver code
public static void Main(String[] args)
{
    int []arr = { 4, 21, 5, 3, 8 };
    int k = 3;
      
    int n = arr.Length;
      
    // Function call
    Console.Write(minimumValue(arr, n, k));    
}
}
 
// This code is contributed by 29AjayKumar

Javascript

<script>
 
// JavaScript program to find the minimum possible of the expression
// by choosing exactly K(? N) integers form given array arr
 
// Function to find the minimum possible of the expression
// by choosing exactly K(? N) integers form given array arr
function minimumValue(arr, n, k)
{
 
    // Sorting the array for least k element selection
    arr.sort((a, b) => a - b);
 
    let answer = 0;
 
    // Select first k elements from sorted array
    for (let i = 0; i < k; i++)
        answer += arr[i] * arr[i];
 
    // Return value of solved expression
    return answer * (2 * k - 2);
}
 
// Driver code
 
    let arr = [ 4, 21, 5, 3, 8 ], k = 3;
     
    let n = arr.length;
     
    // Function call
    document.write(minimumValue(arr, n, k));
      
 
// This code is contributed by Surbhi Tyagi.
 
</script>

Producción

Complejidad de tiempo: O(n * log n)

Espacio Auxiliar: O(1)

Otro método eficiente: este problema se puede resolver de manera eficiente utilizando una cola de prioridad . Como tenemos que encontrar los k elementos más pequeños de la array para resolver la expresión, usamos una cola de prioridad que encontrará los k elementos más pequeños en una complejidad de tiempo O (n * log (k)) donde n es el tamaño de la array y k es el número de elementos más pequeños necesarios. Una vez que obtengamos los k elementos más pequeños en la cola de prioridad, usaremos la expresión simplificada anterior para encontrar el valor mínimo.

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

C++

// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum possible of the expression
// by choosing exactly K(<= N) integers form given array arr
int minimumValue(int arr[], int n, int k)
{
     
    // Using a Priority Queue
    // to find k smallest elements
    priority_queue<int> heap1;
  
    for (int i = 0; i < n; ++i) {
  
        // Insert elements into
        // the priority queue
        heap1.push(arr[i]);
  
        // If size of the priority
        // queue exceeds k then remove
        // the largest element from
        // the priority queue
        if (heap1.size() > k) {
            heap1.pop();
        }
    }
 
    int answer = 0;
 
    // Using first k elements from priority queue
    // to find the minimum value
    for (int i = 0; i < k; i++)
    {
        answer += heap1.top() * heap1.top();
        heap1.pop();
    }
 
    // Return value of solved expression
    return answer * (2 * k - 2);
}
 
// Driver code
int main()
{
    int arr[] = { 4, 21, 5, 3, 8 }, k = 3;
     
    int n = sizeof(arr) / sizeof(arr[0]);
     
    // Function call
    cout << minimumValue(arr, n, k);
     
    return 0;
}
 
// This code is contributed by Pushpesh Raj

Producción

Complejidad de tiempo: O(k+nlog(k)) donde n es el tamaño de la array yk es el número dado de elementos para elegir.
Espacio Auxiliar: O(k) ya que la cola de prioridad en cualquier momento contiene k elementos.

Publicación traducida automáticamente

Artículo escrito por king_tsar y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

C++

Java

Python3

C#

Javascript

C++

Deja una respuesta Cancelar la respuesta