Esempi di algoritmi e prove che sembrano corretti, ma non lo sono

Nella mia introduzione al corso di programmazione, stiamo imparando il metodo di inizializzazione-manutenzione-terminazione per dimostrare che un algoritmo fa quello che ci aspettiamo. Ma abbiamo solo dovuto dimostrare che un algoritmo già noto per essere corretto, è corretto. Non ci è mai stato chiesto di dimostrare che un algoritmo non è corretto.

Esistono esempi classici di algoritmi che sembrano corretti, ma non lo sono? Sto cercando casi in cui l'approccio Initialization-Maintenance-Termination cattura qualcosa che l'intuizione a prima vista non lo fa.

ds.algorithms proofs

— Marin
fonte

Forse di interesse: cs.stackexchange.com/q/29475/755

— DW

Voto perché penso che questa sia una domanda pedagogica molto importante. È leggermente fuori portata per cstheory, ma non conosco una piattaforma migliore per questo, e ci sono molti istruttori di algoritmi nella comunità cstheory. La maggior parte dei corsi di progettazione di algoritmi espone gli studenti solo a correggere algoritmi esistenti e a problemi facilmente risolvibili con tecniche note. Ciò rafforza l'impressione, così attraente per gli studenti, che ci si può fidare in sicurezza della propria sensazione intuitiva che un algoritmo apparentemente plausibile sia giusto. Un buon corso di progettazione di algoritmi dovrebbe fare il contrario!

— Neal Young,

Mi piacerebbe avere una collezione come questa.

— Chandra Chekuri,

Massimo locale 2D

input: matrice bidimensionale $n \times n$ $A$

output: un massimo locale - una coppia tale che non abbia una cella vicina nell'array che contiene un valore strettamente maggiore. $(i,j)$ $A[i,j]$

(Le celle vicine sono quelle tra che sono presenti nell'array.) Quindi, per esempio, 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}$

quindi ogni cella in grassetto è un massimo locale. Ogni array non vuoto ha almeno un massimo locale.

Algoritmo. Esiste un algoritmo -time: basta controllare ogni cella. Ecco un'idea per un algoritmo più veloce e ricorsivo. $O(n^2)$

Dato , definisci la croce in modo che sia composta dalle celle nella colonna centrale e dalle celle nella riga centrale. Prima controlla ogni cella per vedere se la cella è un massimo locale in . In tal caso, restituire una cella del genere. Altrimenti, sia una cella in con il valore massimo. Da $A$ $X$ $X$ $A$ $(i, j)$ $X$ non è un massimo locale, deve avere una cella vicina con un valore maggiore. $(i, j)$ $(i', j')$

Partizione (l'array , meno le celle in ) in quattro quadranti - i quadranti in alto a sinistra, in alto a destra, in basso a sinistra e in basso a destra - in modo naturale. La cella vicina $A \setminus X$ $A$ $X$ con valore maggiore deve trovarsi in uno di quei quadranti. Chiama quel quadrante . $(i', j')$ $A'$

Lemma. Quadrant contiene un massimo locale di . $A'$ $A$

Prova. Considera di iniziare dalla cella . Se non è un massimo locale, passare a un vicino con un valore maggiore. Questo può essere ripetuto fino ad arrivare a una cella che è un massimo locale. Quella cella finale deve essere in , perché è delimitata su tutti i lati da celle i cui valori sono inferiori al valore di cella . Questo dimostra il lemma. $(i', j')$ $A'$ $A'$ $(i', j')$ $\diamond$

L'algoritmo si chiama ricorsivamente sul sotto-array $\frac{n}{2}\times\frac{n}{2}$ per trovare un massimo locale lì, quindi restituisce quella cella. $A'$ $(i, j)$

Il tempo di esecuzione per una matrice soddisfa , quindi $T(n)$ $n\times n$ $T(n) = T(n/2) + O(n)$ . $T(n) = O(n)$

Pertanto, abbiamo dimostrato il seguente teorema:

Teorema. Esiste un algoritmo -time per trovare un massimo locale in un array . $O(n)$ $n\times n$

O abbiamo?

— Neal Young
fonte

In prima lettura, l'unico errore che ho notato è stata la soluzione di ricorrenza. È l'unico errore?

— Radu GRIGore,

La ricorrenza è corretta. L'algoritmo no!

— Neal Young,

Ah, sì, ho fatto un errore stupido con la ricorrenza. Vedo il problema: il massimo che dimostri esiste non è (necessariamente) quello che trovi. E quello che trovi ignora la X.

— Radu GRIGore

Ecco un esempio:

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