Puedes hacerlo mucho mejor que la fuerza bruta. Creo que se puede resolver en [math] O (n \ log {k}) [/ math] donde n es el número de todos los elementos en los arrays yk es el número de arrays.
Esta es mi solución:
Deje que M sea un montón mínimo de mínimos en cada una de estas matrices.
ARRAYS = [
[1 1000 2000]
[20 1001 5000]
[55 1002 222222]
]
- Cómo evitar mostrar mi transcripción durante el proceso de entrevista
- Durante una entrevista, ¿cómo respondería a la pregunta "describa lo que sabe sobre el aprendizaje automático"?
- ¿Cuál es la diferencia entre compilación e interpretación justo a tiempo?
- ¿Cómo puedo clasificar / calificar a los programadores?
- ¿Cómo me preparo para una entrevista in situ para el rol de ingeniero de desarrollo de software en Amazon Hyderabad?
M = [1, 20, 55]
No hay rango que comience con min (M) y sea más corto que (min (M), max (M)). Por ejemplo, (1,55) es el rango más corto que comienza con 1. Es decir, cualquier otro rango que comience con 1 tendrá la misma longitud o tendrá un elemento mayor que 55.
Hasta ahora, el min_range es (1,55).
Ahora eliminemos 1:
ARRAYS = [
[1000 2000]
[20 1001 5000]
[55 1002 222222]
]
M = [20 55 1000], min (M) = 20, max (M) = 1000. Entonces, el rango mínimo a partir de 20 es (20, 1000).
min_range sigue siendo (1,55).
Ahora eliminemos 20:
ARRAYS = [
[1000 2000]
[1001 5000]
[55 1002 222222]
]
M = [55 1000 1001], min (M) = 50, max (M) = 1001. Entonces, el rango mínimo a partir de 55 es (55, 1001). ¡Ningún cambio en min_range!
Ahora eliminemos 55:
ARRAYS = [
[1000 2000]
[1001 5000]
[1002 222222]
]
M = [1000 1001 1002], min (M) = 1000, max (M) = 1002. Entonces, el rango mínimo a partir de 1000 es (1000, 1002).
Ahora tenemos un nuevo min_range: (1000,1002).
Continuamos esto hasta que una de las listas se vacía, y luego tenemos el min_range.
Esta es mi implementación de c ++ 11 de esto (que en lugar de eliminar elementos almacena un índice de barrido para cada vector):
#include #include #include #include #include #include using std::get; using std::numeric_limits; using std::pair; using std::priority_queue; using std::vector; pair find_min_range(const vector<vector>& arrays) { // The result. pair min_range{ numeric_limits::min(), numeric_limits::max() }; // Sweeping index on each row. vector indices(arrays.size()); // M. std::priority_queue<pair, std::vector<pair>, std::greater<pair>> minimums; // max(M). auto max = arrays[0][0]; for (auto i = 0; i < arrays.size(); i++) { auto v = arrays[i][0]; minimums.push({v, i}); if (max long(max) - long(min_val)) { min_range = {min_val, max}; } indices[min_row]++; if (indices[min_row] == arrays[min_row].size()) { return min_range; } auto v = arrays[min_row][indices[min_row]]; if (max < v) { max = v; } minimums.push({v, min_row}); } return min_range; } int main() { vector<vector> a { {1, 1000, 2000}, {20, 1001, 5000}, {55, 1002, 222222} }; auto res = find_min_range(a); printf("Minimum range is (%d, %d)\n", res.first, res.second); return 0; }