Exemples d'algorithmes et de preuves qui semblent corrects, mais qui ne le sont pas

Dans mon cours d'introduction à la programmation, nous apprenons la méthode d'initialisation-maintenance-terminaison pour prouver qu'un algorithme fait ce que nous attendons de lui. Mais nous n'avons eu qu'à prouver qu'un algorithme déjà connu pour être correct est correct. On ne nous a jamais demandé de montrer qu'un algorithme n'est pas correct.

Existe-t-il des exemples classiques d'algorithmes qui semblent corrects, mais qui ne le sont pas? Je recherche des cas où l'approche Initialisation-Maintenance-Arrêt intercepte quelque chose que l'intuition à première vue ne fait pas.

ds.algorithms proofs

— Marin
source

Peut-être d'intérêt: cs.stackexchange.com/q/29475/755

— DW

Voter parce que je pense que c'est une question pédagogique très importante. Il est légèrement hors de portée de cstheory, mais je ne connais pas de meilleure plate-forme pour cela, et il existe de nombreux instructeurs d'algorithmes dans la communauté cstheory. La plupart des cours de conception d'algorithmes n'exposent les étudiants qu'à des algorithmes corrects existants et à des problèmes qui peuvent être facilement résolus en utilisant des techniques connues. Cela renforce l'impression, si attrayante pour les étudiants, que l'on peut avoir confiance en son sentiment intuitif qu'un algorithme apparemment plausible est juste. Un bon cours de conception d'algorithmes devrait faire le contraire!

— Neal Young

J'aimerais avoir une collection comme ça.

— Chandra Chekuri

Maximum local 2D

entrée: tableau bidimensionnel $n \times n$ $A$

sortie: un maximum local - une paire telle que n'a pas de cellule voisine dans le tableau qui contient une valeur strictement supérieure. $(i,j)$ $A[i,j]$

(Les cellules voisines sont celles parmi qui sont présentes dans le tableau.) Ainsi, par exemple, si est $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}$

alors chaque cellule en gras est un maximum local. Chaque tableau non vide a au moins un maximum local.

Algorithme. Il existe un algorithme : il suffit de vérifier chaque cellule. Voici une idée pour un algorithme récursif plus rapide. $O(n^2)$

Étant donné , définissez la croix pour qu'elle se compose des cellules de la colonne du milieu et des cellules de la ligne du milieu. Tout d' abord vérifier chaque cellule pour voir si la cellule est un maximum local dans . Si oui, renvoyez une telle cellule. Sinon, soit une cellule de avec une valeur maximale. Puisque n'est pas un maximum local, il doit avoir une cellule voisine de plus grande valeur. $A$ $X$ $X$ $A$ $(i, j)$ $X$ $(i, j)$ $(i', j')$

Partitionnez (le tableau , moins les cellules de ) en quatre quadrants - les quadrants supérieur gauche, supérieur droit, inférieur gauche et inférieur droit - de manière naturelle. La cellule voisine de plus grande valeur doit être dans l'un de ces quadrants. Appelez ce quadrant . $A \setminus X$ $A$ $X$ $(i', j')$ $A'$

Lemme. Quadrant contient un maximum local de . $A'$ $A$

Preuve. Pensez à commencer par la cellule . S'il ne s'agit pas d'un maximum local, déplacez-vous vers un voisin avec une valeur plus élevée. Cela peut être répété jusqu'à arriver à une cellule qui est un maximum local. Cette cellule finale doit être en , car est délimité de tous côtés par des cellules dont les valeurs sont inférieures à la valeur de la cellule . Cela prouve le lemme. $(i', j')$ $A'$ $A'$ $(i', j')$ $\diamond$

L'algorithme s'appelle récursivement sur le sous-tableaupour y trouver un maximum local, puis renvoie cette cellule. $\frac{n}{2}\times\frac{n}{2}$ $A'$ $(i, j)$

Le temps d'exécution pour une matrice satisfait , donc . $T(n)$ $n\times n$ $T(n) = T(n/2) + O(n)$ $T(n) = O(n)$

Ainsi, nous avons prouvé le théorème suivant:

Théorème. Il existe un algorithme pour trouver un maximum local dans un tableau . $O(n)$ $n\times n$

Ou avons-nous?

— Neal Young
source

En première lecture, la seule erreur que j'ai repérée était la solution de récurrence. Est-ce la seule erreur?

— Radu GRIGore

La récurrence est correcte. L'algorithme ne l'est pas!

— Neal Young

Ah, oui, j'ai fait une erreur stupide avec la récurrence. Je vois le problème: le maximum dont vous prouvez l'existence n'est pas (nécessairement) ce que vous trouvez. Et ce que vous trouvez ignore le X.

— Radu GRIGore

Voici un exemple:

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

A^{'}

$A'$

A

$A$