Exemplos de algoritmos e provas que parecem corretos, mas não são

Na minha introdução ao curso de programação, estamos aprendendo sobre o método Initialization-Maintenance-Termination de provar que um algoritmo faz o que esperamos. Mas apenas tivemos que provar que um algoritmo já conhecido como correto está correto. Nunca fomos solicitados a mostrar que um algoritmo não está correto.

Existem exemplos clássicos de algoritmos que parecem corretos, mas não são? Estou procurando casos em que a abordagem Inicialização, Manutenção e Terminação capta algo que a intuição à primeira vista não capta.

ds.algorithms proofs Marin
fonte

Possivelmente de interesse: cs.stackexchange.com/q/29475/755

Voto positivo porque acho que essa é uma questão pedagógica muito importante. Está um pouco fora do escopo da cstheory, mas não conheço uma plataforma melhor para ela, e há muitos instrutores de algoritmos na comunidade da cstheory. A maioria dos cursos de design de algoritmos expõe os alunos apenas a algoritmos corretos e existentes e a problemas facilmente solucionáveis usando técnicas conhecidas. Isso reforça a impressão, tão atraente para os alunos, que podemos confiar com segurança no sentimento intuitivo de que um algoritmo aparentemente plausível está certo. Um bom curso de design de algoritmo deve fazer o oposto!

Neal Young

Eu adoraria ter uma coleção como esta.

Chandra Chekuri 31/03/19

Máximo local 2D

entrada: bidimensional matriz $n \times n$ $A$

saída: um máximo local - um par forma que não tenha célula vizinha na matriz que contenha um valor estritamente maior. $(i,j)$ $A[i,j]$

(As células vizinhas são aquelas entre que estão presentes na matriz.) Então, por exemplo, se é $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}$

então cada célula em negrito é um máximo local. Toda matriz não vazia possui pelo menos um máximo local.

Algoritmo. Existe um algoritmo de tempo de : basta verificar cada célula. Aqui está uma idéia para um algoritmo recursivo mais rápido. $O(n^2)$

Dado , defina a cruz para consistir nas células da coluna do meio e nas células da linha do meio. Primeiro verifique cada célula para ver se a célula é um máximo local em . Nesse caso, retorne essa célula. Caso contrário, seja uma célula em com o valor máximo. Como não é um máximo local, ele deve ter uma célula vizinha com maior valor. $A$ $X$ $X$ $A$ $(i, j)$ $X$ $(i, j)$ $(i', j')$

Partição (a matriz , menos as células em ) em quatro quadrantes - os quadrantes superior esquerdo, superior direito, inferior esquerdo e inferior direito - da maneira natural. A célula vizinha com maior valor deve estar em um desses quadrantes. Chame esse quadrante de . $A \setminus X$ $A$ $X$ $(i', j')$ $A'$

Lema. Quadrant contém um máximo local de . $A'$ $A$

Prova. Considere começar na célula . Se não for um máximo local, vá para um vizinho com um valor maior. Isso pode ser repetido até chegar a uma célula que seja o máximo local. Essa célula final deve estar em , porque é limitada por todos os lados por células cujos valores são menores que o valor da célula . Isso prova o lema. $(i', j')$ $A'$ $A'$ $(i', j')$ $\diamond$

O algoritmo se chama recursivamente no sub-matrizpara encontrar um máximo locallá e, em seguida, retorna essa célula. $\frac{n}{2}\times\frac{n}{2}$ $A'$ $(i, j)$

O tempo de execução para um satisfaz matriz , então . $T(n)$ $n\times n$ $T(n) = T(n/2) + O(n)$ $T(n) = O(n)$

Assim, provamos o seguinte teorema:

Teorema. Há um -tempo algoritmo para encontrar um local,-máxima numa matriz. $O(n)$ $n\times n$

Ou nós?

Neal Young
fonte

Na primeira leitura, o único erro que vi foi a solução de recorrência. Esse é o único erro?

Radu GRIGore 31/03/19

A recorrência está correta. O algoritmo não é!

Neal Young

Ah, sim, cometi um erro estúpido com a recorrência. Eu vejo o problema: o máximo que você prova que existe não é (necessariamente) o que você encontra. E o que você encontra ignora o X.

Radu GRIGore

(\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}$

A^{'}

$A'$

A

$A$

Exemplos de algoritmos e provas que parecem corretos, mas não são

Respostas: