[LeetCode 373] Encuentra K pares con sumas más pequeñas

Se le dan dos matrices enteras nums1 y nums2 ordenadas en orden ascendente y un entero k.

Defina un par (u, v) que consta de un elemento de la primera matriz y un elemento de la segunda matriz.

Encuentre los k pares (u1, v1), (u2, v2) ... (uk, vk) con las sumas más pequeñas.

 

 

Ejemplo 1:

 

Entrada: nums1 = [1,7,11], nums2 = [2,4,6], k = 3  Salida: [[1,2], [1,4], [1,6]]  Explicación: El primero Se devuelven 3 pares de la secuencia:    [1,2], [1,4], [1,6], [7,2], [7,4], [11,2], [7,6], [11,4], [11,6]

 

Ejemplo 2

 

Entrada: nums1 = [1,1,2], nums2 = [1,2,3], k = 2 
Salida: [1,1], [1,1] 
Explicación: Los primeros 2 pares se devuelven de la secuencia: 
             [1,1], [1,1], [1,2], [2,1], [1,2], [2,2], [1,3], [1,3], [2 , 3]

 

Ejemplo 3

 

Entrada: nums1 = [1,2], nums2 = [3], k = 3 
Salida: [1,3], [2,3] 
Explicación: Todos los pares posibles se devuelven de la secuencia: [1,3], [ 2,3]

 

Observación clave: K pares && más pequeños. -> Montón

 

Solución Min Heap. Tiempo de ejecución de O (K * log K), espacio de O (K)

1. cree un montón mínimo que tome el índice de un par y compare la suma de pares.

2. agregue los primeros pares Math.min (nums1.length, k) en formato (i, 0) al montón mínimo. i es el índice de nums1, 0 representa el índice 0 de nums2.

3. encuestar desde el montón mínimo, agregar el par para responder, luego crear un nuevo par con el índice nums2 incrementado en 1 y agregarlo nuevamente al montón mínimo.

4. repita 3 hasta que haya k pares o no queden pares en el montón mínimo.

 

Una variación de este algoritmo es agregar solo el par más pequeño (0, 0) al montón mínimo. Luego, cada vez que encuestamos a un par, intentamos aumentar el primer índice del par; luego intente aumentar el segundo índice del par. Sin embargo, necesitaremos algunos libros adicionales para evitar agregar el mismo par más de una vez. 

 

clase Solución {
     public List <List <Integer>> kSmallestPairs ( int [] nums1, int [] nums2, int k) { 
        List <List <Integer>> res = new ArrayList <> ();
        if (nums1.length == 0 || nums2.length == 0 ) {
             return res; 
        } 
        PriorityQueue < int []> minPq = new PriorityQueue <> ((a, b) -> {
             return nums1 [a [0]] + nums2 [a [1]] - nums1 [b [0]] - nums2 [b [1 ]]; 
        }); 
        Conjunto<Integer> [] set = new Set [nums1.length];
        for ( int i = 0; i <nums1.length; i ++ ) { 
            set [i] = new HashSet <> (); 
        } 
        minPq.add ( nuevo  int [] {0, 0 }); 
        conjunto [ 0] .add (0 );
        while (k> 0 && minPq.size ()> 0 ) {
             int [] curr = minPq.poll (); 
            List <Integer> list = new ArrayList <> (); 
            list.add (nums1 [curr [ 0 ]]);
            list.add (nums2 [curr [ 1 ]]); 
            res.add (lista); 
            if (curr [0] <nums1.length - 1 &&! set [curr [0] + 1] .contains (curr [1 ])) { 
                minPq.add ( new  int [] {curr [0] + 1, curr [1 ]}); 
                set [curr [ 0] + 1] .add (curr [1 ]); 
            } 
            if (curr [1] <nums2.length - 1 &&! set [curr [0]]. contiene (curr [1] + 1 )) { 
                minPq.add ( nuevo  int [] {curr [0], curr [ 1] + 1 }); 
                set [curr [ 0]]. add (curr [1] + 1 ); 
            } 
            k -; 
        } 
        return res; 
    } 
}

 

 

 

 

Problemas relacionados

[LeetCode 373] Encuentra K pares con sumas más pequeñas

 

[LeetCode 719] Encuentra la K-ésima distancia de par más pequeña