¿Cuál es el enfoque algorítmico para encontrar el primer entero positivo que falta si se proporciona una matriz entera sin clasificar en O (n) complejidad de tiempo y espacio constante?

Aquí hay un algoritmo que toma O (n) tiempo y O (1) espacio
Observaciones: –
La respuesta siempre está en [1, len (array)] (fácil de probar, pruébalo tú mismo)

Algoritmo:-
denotamos nuestra matriz con A [] e índices iterativos con i
Paso 1:-
Iterar a través de la matriz A
establecer cur_val = A [i]
si cur_val es negativo o mayor que n, entonces
continuar / ignorar
más
establezca cur_val en la posición de la matriz con index = cur_val

Entonces, después de que nuestro algoritmo termina la ejecución, coloca elementos en la matriz en el rango (0, n) en índices que son iguales a su valor.

Paso 2:-
Ahora solo recorra nuevamente la matriz y descubra para qué índice más pequeño i> = 1, A [i]! = I, informe que i

Ejecución del algoritmo para el caso de prueba 1: –
A [] = {1,2,0}
después del paso 1: – A [] = {0,1,2}
después del paso 2: – ans = 3, (ya que para todos los 1 <= índices <3 A [i] == i)

Ejecución del algoritmo para el caso de prueba 2: –
A [] = {3,4, -1,1}
después del paso 1: – A [] = {3,1, -1,3}
después del paso 2: – ans = 2, (ya que A [2]! = 2, observe que la respuesta no puede ser 0 ya que tenemos que encontrar el número positivo más pequeño)

Aquí hay una implementación de esa idea en C ++: –

#include
usando el espacio de nombres estándar;
int main () {
int n, t;
vector v;
cout << "Ingrese el tamaño de la matriz \ n";
cin >> n;
cout << "Ahora ingrese" << n << "elementos \ n";

para (int i = 0; i <n; ++ i) {
cin >> t;
v.push_back (t);
}

para (int i = 0; i <n; i ++) {
int val = v [i];
if ((val = v.size ())) {continuar;}
int curval = v [i], nextval = v [v [i]];
while (curval! = nextval) {
v [curval] = curval;
curval = nextval;
if ((curval = v.size ())) {continuar;}
nextval = v [nextval];
}

}
cout << "\ nMatriz final \ n";
for (int i = 0; i <v.size (); i ++) {
cout << v [i] << "";
}
// cout << "\ n";
int ans = v.size ();
for (int i = 1; i <v.size (); i ++) {
if (v [i]! = i) {
ans = i;
descanso;
}
}
cout << "\ n \ nAns: -";
cout << ans << "\ n";
}

Aquí hay un enlace sobre cómo usar este código Ideone.com

Aquí, si el rango de números está restringido entre -10 ^ 6 y 10 ^ 6, puede crear dos matrices booleanas, una para positivo y otra para negativo. Inicialice la matriz booleana con falso y marque los elementos presentes en la matriz como verdaderos. Ahora, si atraviesas la matriz, el primer elemento ‘falso’ es el primer elemento que falta. Espero que ayude 🙂

Editar: dado que necesita primero un número positivo faltante, puede ignorar los negativos. El tamaño de la matriz en tal caso se puede aumentar aún más a 10 ^ 7. Para números aún más altos, puede pensar en usar conjuntos de bits.

No es una respuesta directa a su pregunta (la respuesta de Akshay está bien), pero curiosamente, si la matriz no contiene duplicados, puede hacerlo en [matemáticas] O (n \ log n) [/ matemáticas] tiempo y [matemáticas] O (1) [/ math] espacio sin modificar la matriz de entrada, utilizando una búsqueda binaria.

Podemos usar la misma idea en la que se basa el algoritmo Quickselect.
Primero, con un simple recorrido e intercambios, podemos poner todos los números negativos en el lado izquierdo de la matriz, lo que toma O (n) tiempo y O (1) espacio.
Ahora consideraremos solo la parte no negativa que está a la derecha.
Podemos encontrar el elemento mínimo entre los no negativos nuevamente en O (n) tiempo y O (1) espacio.
Ahora, podemos usar la misma idea que usa Quickselect. Si elegimos un pivote aleatorio en un rango y luego dividimos los elementos, estamos seguros de dónde se supone que la posición del pivote elegido está en una versión ordenada de la matriz. Entonces, en base a eso, podemos continuar particionando a la derecha o a la izquierda dependiendo de si el pivote está en su índice derecho, suponiendo que no haya un entero perdido antes en la secuencia ordenada o que el pivote tenga 1 índice menos de lo que debería ser si no faltara entero a la izquierda, lo que significa que el entero faltante debe estar en la parte izquierda de la partición. Seguimos haciéndolo recursivamente hasta llegar a un elemento que se supone que es 1 más o menos que el elemento que falta.
Al final, este algoritmo tiene la misma complejidad de tiempo esperada de Quickselect, que es O (n) complejidad de tiempo y O (1) complejidad de espacio si usamos la recursión de cola para ello o el espacio esperado de O (log2n) si no lo hacemos (esto toma en cuenta que tendremos en promedio llamadas recursivas log2n de nuestra función y, por lo tanto, los cuadros de pila log2n ocuparán memoria).

Bien leído desde aquí definitivamente obtienes tu respuesta

LeetCode – Primera falta positiva (Java)

More Interesting

Cómo encontrar un elemento en un árbol de búsqueda binario

¿Qué estrategias o algoritmos se utilizan para agrupar rutas de pasajeros en función de la ubicación y la hora de salida?

¿Cuál es la mejor manera de implementar un iterador para un BST?

Cómo obtener maestría en estructuras de datos y algoritmos

¿Es la incapacidad de implementar estructuras de datos básicas como una lista doblemente enlazada, un árbol con punteros primarios usando un código seguro la mayor debilidad de Rust?

¿Cuál es una forma rápida de factorizar números con 12 dígitos sin utilizar ningún algoritmo de división de prueba o Pollard-Rho?

Un árbol binario completamente equilibrado tiene 187 hojas. ¿Cuál es la altura del árbol?

Programación de computadoras: Como ingeniero de software, ¿qué cosas crees que son "innecesariamente complicadas"?

¿Qué es el algoritmo de clasificación de Reddit?

¿Las secuencias y series son importantes para el aprendizaje de algoritmos?

¿Cuál es el tiempo de entrenamiento promedio y el tiempo de prueba de los algoritmos de aprendizaje automático más comunes?

Cómo establecer un límite máximo y mínimo para una variable entera / flotante en la definición

¿Qué técnicas eficientes ha intentado rastrear un algoritmo o un código de programa manualmente, sin usar una computadora?

Cómo calcular la similitud semántica entre un automóvil y una bicicleta mediante el algoritmo Jian y Conrath

¿Cómo hacemos que una selección sea estable?