Ejemplos de algoritmos y pruebas que parecen correctos, pero no lo son

En mi introducción al curso de programación, estamos aprendiendo sobre el método de inicialización-mantenimiento-terminación para probar que un algoritmo hace lo que esperamos. Pero solo hemos tenido que demostrar que un algoritmo que ya se sabe que es correcto, es correcto. Nunca se nos ha pedido que demostremos que un algoritmo no es correcto.

¿Hay ejemplos clásicos de algoritmos que se vean correctos, pero no lo son? Estoy buscando casos en los que el enfoque de inicialización-mantenimiento-terminación capte algo que la intuición de primera vista no.

ds.algorithms proofs

— Marin
fuente

Posiblemente de interés: cs.stackexchange.com/q/29475/755

— DW

Votación porque creo que esta es una pregunta pedagógica muy importante. Está un poco fuera de alcance para cstheory, pero no conozco una mejor plataforma para ello, y hay muchos instructores de algoritmos en la comunidad cstheory. La mayoría de los cursos de diseño de algoritmos exponen a los estudiantes solo a los algoritmos correctos existentes y a problemas que se pueden resolver fácilmente utilizando técnicas conocidas. Esto refuerza la impresión, tan atractiva para los estudiantes, que uno puede confiar con seguridad en la sensación intuitiva de que un algoritmo aparentemente plausible es correcto. ¡Un buen curso de diseño de algoritmos debería hacer lo contrario!

— Neal Young

Me encantaría tener una colección como esta.

— Chandra Chekuri

Máximo local 2D

entrada: 2 dimensiones matriz $n \times n$ $A$

salida: un máximo local: un par tal que no tiene una celda vecina en la matriz que contenga un valor estrictamente mayor. $(i,j)$ $A[i,j]$

(Las celdas vecinas son aquellas entre que están presentes en la matriz). Entonces, por ejemplo, si es $A[i, j+1], A[i, j-1], A[i-1, j], A[i+1, j]$ $A$

\begin{array}{cccc} 0 & 1 & 3 & 4 \\ 3 & 2 & 3 & 1 \\ 2 & 5 & 0 & 1 \\ 4 & 0 & 1 & 3 \end{array}

$\begin{array}{cccc} 0&1&3&\mathbf{4}\\ \mathbf{3}&2&\mathbf{3}&1\\ 2&\mathbf{5}&0&1\\ \mathbf{4}&0&1&\mathbf{3}\end{array}$

entonces cada celda en negrita es un máximo local. Cada matriz no vacía tiene al menos un máximo local.

Algoritmo. Hay un algoritmo de tiempo : simplemente verifique cada celda. Aquí hay una idea para un algoritmo más rápido y recursivo. $O(n^2)$

Dado , defina la cruz para que consista en las celdas en la columna central y las celdas en la fila central. En primer lugar comprobar cada celda de para ver si la célula es un máximo local en . Si es así, devuelva dicha celda. De lo contrario, sea una celda en con un valor máximo. Como no es un máximo local, debe tener una celda vecina con un valor mayor. $A$ $X$ $X$ $A$ $(i, j)$ $X$ $(i, j)$ $(i', j')$

Partición (la matriz , menos las celdas en ) en cuatro cuadrantes (los cuadrantes superior izquierdo, superior derecho, inferior izquierdo e inferior derecho) de la manera natural. La celda vecina con mayor valor debe estar en uno de esos cuadrantes. Llame a ese cuadrante . $A \setminus X$ $A$ $X$ $(i', j')$ $A'$

Lema Cuadrante contiene un máximo local de . $A'$ $A$

Prueba. Considere comenzar en la celda . Si no es un máximo local, muévase a un vecino con un valor mayor. Esto se puede repetir hasta llegar a una celda que es un máximo local. Esa celda final tiene que estar en , porque está delimitada por todos lados por celdas cuyos valores son más pequeños que el valor de la celda . Esto prueba el lema. $(i', j')$ $A'$ $A'$ $(i', j')$ $\diamond$

El algoritmo se llama a sí mismo recursivamente en la sub-matriz para encontrar un máximo local allí, luego devuelve esa celda. $\frac{n}{2}\times\frac{n}{2}$ $A'$ $(i, j)$

El tiempo de ejecución para una matriz satisface , entonces . $T(n)$ $n\times n$ $T(n) = T(n/2) + O(n)$ $T(n) = O(n)$

Por lo tanto, hemos demostrado el siguiente teorema:

Teorema. Existe un algoritmo -time para encontrar un máximo local en una matriz . $O(n)$ $n\times n$

O tenemos?

— Neal Young
fuente

En la primera lectura, el único error que vi fue la solución de recurrencia. ¿Es ese el único error?

— Radu GRIGore

La recurrencia es correcta. El algoritmo no lo es!

— Neal Young

Ah, sí, cometí un error tonto con la recurrencia. Veo el problema: el máximo que demuestras que existe no es (necesariamente) lo que encuentras. Y lo que encuentras ignora la X.

— Radu GRIGore

He aquí un ejemplo:

(\begin{matrix} 2 & 1 & 4 & 3 & 3 & 0 & 0 \\ 1 & 0 & 1 & 2 & 3 & 0 & 0 \\ 0 & 1 & 0 & 2 & 3 & 0 & 0 \\ 2 & 2 & 2 & 2 & 2 & 2 & 2 \\ 3 & 3 & 3 & 2 & 3 & 3 & 3 \\ 0 & 0 & 3 & 2 & 3 & 0 & 0 \\ 0 & 0 & 3 & 2 & 3 & 0 & 0 \end{matrix})

$\begin{pmatrix}2&1&4&3&3&0&0\\1&0&1&2&3&0&0\\0&{\color{red}1}&0&2&3&0&0\\2&2&2&2&2&2&2\\3&3&3&2&3&3&3\\0&0&3&2&3&0&0\\0&0&3&2&3&0&0\end{pmatrix}$

— Radu GRIGORE

@Marin, lo que falta es una prueba de que un máximo local de también es un máximo local de , porque no es cierto. (De alguna manera me gusta mi redacción inicial, pero no es precisa y no está clara. Pero puede ayudar a la intuición.)

A^{'}

$A'$

A

$A$

— Radu GRIGore