Guardiamo insieme il codice di ‘dancing_links_queens.rb‘:

def initialize()
    labels = (1..42).to_a
    @dla = DancingLinksArena.new(labels,[false]*16 + [true]*26)
    given_list = []
    row_data = []

    8.times do |x|
      8.times do |y|
        row_data[0] = x+1
        row_data[1] = y+1 + 8
        row_data <<  ((y+1) - (x+1)) + 7  + 16  unless [-7,7].include?(y - x)
        row_data <<  (x + y + 2) - 2 + 13 + 16  unless [0,14].include?(x + y)
        new_row = @dla.add_initial_row(row_data)
        row_data = []
      end
    end
  end

Nella prima riga creo un array di 42 elementi ( 8 righe + 8 colonne + 13 diagonali da sx a dx + 13 diagonali da dx a sx ), da notare che considero solo 13 diagonali per direzione ( e non 15 ) perchè 2 contengono un solo elemento. Ognuno di questi 42 elementi diverrà una colonna nella matrice DLX.

Nella seconda riga creo un oggetto ‘Dancing Links’ al quale passo l’array di etichette e un array di 16 ‘true’ e 26 ‘false’, questo perchè le prime 16 colonne sono primarie (cioè dovranno contenere esattamente un 1) mentre le ultime 26 sono secondarie (cioè possono contenere o 0 o 1 elemento). Questa scelta è stata dettata dal fatto che mentre per ogni riga e ogni colonna della scacchiera dovrà necessariamente essere presente una regina, lo stesso non è valido per ogni diagonale ( abbiamo solo 8 regine e 26 diagonali… ).

Ora mi resta solo da impostare per ognuna delle 64 caselle della scacchiera le relative costrizioni ed aggiungerle alla DLA, nel dettaglio per ogni casella devo specificare il ‘nome’ (da 1 a 42) dei label corrispondenti alla costrazione che definisce tale casella; facciamo un esempio, per la casella 1-1 questi sono i label interessati:

• il label 1 che corrisponde alla riga 1
• il label 9 che corrisponde alla colonna 1
• il label 36 che identifica la diagonale che interessa la casella 1-1

Potete visionare e testare l’esempio completo sul mio account di github

Per rendere il tutto più utilizzabile ho inoltre allegato alla libreria anche un esempio: un piccolo programma che usando la matrice di costrizione spiegata nell’articolo di due settimane fa è capace di risolvere un Sudoku.

Potete trovare questo programma all’interno del mio repository di GitHub, nella sottocartella examples/sudoku; per eseguirlo lanciate il file sudoku.rb.

La settimana prossima proporrò un tutorial nel quale utilizzeremo questa libreria per risolvere  il famosissimo problema delle otto regine.

L’algoritmo DLX è stato inventato da Donald Knuth (il pdf originale è disponibile gratuitamente) ed è essenzialmente un’implementazione performante di un algoritmo di backtracking (Algoritmo X).

L’algoritmo X si applica a problemi chiamati ‘Exact Cover Problems’; tali problemi presentano (genericamente) questo enunciato:

Data una matrice di soli ’0′ e ’1′ è possibile trovare un sottoinsieme di righe tali che per ogni colonna vi sia uno e uno solo ’1′ ?

L’approccio dell’algoritmo X per risolvere un problema come questo è il seguente (data una matrice A):

1. Se A è vuota il problema è risolto
2. Altrimenti scegli una colonna c
3. Scegli una riga r, tale che A[r,c] = 1
4. Includi r nella soluzione parziale
5. Per ogni j che soddisfi A[r,j] = 1
   1. cancella la colonna j da A
   2. Per ogni i che soddisfi A[i,j] = 1
      1. cancella la riga i da A
6. Ripeti questo algoritmo iterativamente sulla matrice A così ridotta

Il problema che rende questo algoritmo molto più laborioso di quanto non sembri è il punto 3. Knuth ci spiega infatti che la scelta della riga r determina la solvibilità o meno del problema (cioè se scegliamo la r giusta il problema si risolve, altrimenti no); questo ci costringe a provare iterativamente tutte le r candidate fino a che non troviamo quella giusta (il che equipara l’algoritmo X ad un algoritmo di backtracking).

I Dancing Links aiutano a velocizzare (in termini di esecuzione) l’algoritmo X offrendo una struttura di memorizzazione dati molto intelligente; Supponiamo di memorizzare solo gli ’1′ della matrice A, e di farlo nel seguente modo:

1. Creiamo un’oggetto Nodo che contiene 4 puntatori ad altrettanti oggetti nodi (su,giu,sinistra e destra) e un puntatore ad un oggetto Colonna.
2. Creiamo un oggetto Colonna < Nodo con in più alcune informazioni sulla quantità di nodi che contiene (diciamo un campo size).
3. Creiamo un’istanza un pò particolare dell’oggetto colonna (diciamo colonna 0) che punti al primo oggetto colonna della nostra matrice.

Il risultato è illustrato egregiamente a pagina 6 del pdf originale di Knuth.

Ma… dove risiede la velocità nell’operare su una struttura simile ? Se pensate ad un classico algoritmo di backtracking ricorderete che la parte più difficile/onerosa da gestire era quella legata al ripristino dello stato del sistema all’istante n (questo avveniva ogni volta che si realizzava che i passaggi n+1..n+k non portavano ad una soluzione).

Con i Dancing Links invece il tutto è leggermente più semplice, pensiamo infatti all’operazione ‘Inserisco un nodo’:

1. Prendo x: un nodo da inserire tra i nodi k e m
2. k.giu = x
3. m.su = x
4. x.su  = k
5. x.giu = m
6. (k.colonna (equivalente a m.colonna)).size += 1

In questo breve pseudocodice ho escluso i puntatori destra e sinistra ma ormai il funzionamento dovrebbe essere abbastanza chiaro.

Il tutto in Ruby

Ho appena finito il porting dell’algorimo DLX implementato da Stan Chesnutt nel suo ‘Sudoku Solver’ in linguaggio Ruby, per il momento potete trovare tutti i sorgenti alla mia pagina di GitHub, nel prossimo articolo utilizzeremo quanto creato per sviluppare il risolvi-sudoku, che a sua volta verrà poi utilizzato per il più ambizioso genera-sudoku.

La prima cosa che ho scoperto è che non è stato ancora dimostrato il numero minimo di cifre che è necessario esporre (cioè visualizzare ‘completate’ all’inizio del puzzle) per garantire al Sudoku una soluzione univoca; al momento sono stati trovati Sudoku validi con 17 cifre esposte.

Ma come si determina quando un Sudoku ha una soluzione univoca?

Il primo articolo che ho trovato in questo senso è una pubblicazione scientifica chiamata Sudoku Squares and Chromatic Polynomials che si ‘limita’ a dimostrare che per garantire una soluzione univoca un Sudoku deve avere, tra le sue celle esposte, almeno 8 delle 9 cifre.

E’ stato inoltre dimostrato che per avere una soluzione univoca un Sudoku deve necessariamente esporre almeno una casella all’interno dell’area illustrata in questa immagine.

Chiaramente queste due dimostrazioni mi aiutano soltanto ad escludere a priori alcuni Sudoku ma non mi danno garanzie ne in un senso ne nell’altro nel caso che il mio puzzle superi le richieste espresse; in questo caso sembra che un buon modo per valutare l’unicità delle soluzioni du un Sudoku sia il DLX ovvero il metodo dei Dancing Links

I Dancing Links:

La tecnica dei Dancing Links è stata inventata da Donald Knuth come metodo risolutivo per l’Algoritimo X da lui stesso inventato. Secondo questa interpretazione il problema posto dai Sudoku viene visto come una serie di vincoli che legano gruppi di possibili valori.

Cerco di spiegarmi: per ogni Sudoku esistono 81 caselle, ognuna delle quali può ospitare 9 cifre (nel senso che sono virtualmente nove le cifre che concorrono ad insediare una casella), quindi possiamo dire che:

R1C1 = {R1C1#1 R1C1#2 R1C1#3 R1C1#4 R1C1#5 R1C1#6 R1C1#7 R1C1#8 R1C1#9 }
R1C2 = {R1C2#1 R1C2#2 R1C2#3 R1C2#4 R1C2#5 R1C2#6 R1C2#7 R1C2#8 R1C2#9 }
...
R9C9 = {R9C9#1 R9C9#2 R9C9#3 R9C9#4 R9C9#5 R9C9#6 R9C9#7 R9C9#8 R9C9#9 }

cioè che per la prima casella in alto a sx ( R1C1: Riga 1 Colonna 1 ) ci sono 9 potenziali valori (marcati come R1C1#1..R1C1#9), lo stesso discorso si può fare per tutte le altre 80 celle ottenendo un numero complessivo di 81(celle) * 9(potenziali valori per cella) = 729 elementi del tipo “RxCy#z.

Ora che abbiamo definito questo primo set di vincoli (bhe, sono vincoli a tutti gli effetti; abbiamo assegnato ad ogni cella un particolare sottoinsieme di valori potenziali) possiamo prendere in considerazione le altre regole sancite da questo gioco:

Per ogni colonna ogni cifra può comparire una sola volta:

Modellizziamo questa regola usando la sintassi precedente ed associando ad ogni coppia (colonna/valore) i valori potenziali che la soddisfano:

C1#1 = {R1C1#1, R2C1#1, R3C1#1, R4C1#1, R5C1#1, R6C1#1, R7C1#1, R8C1#1, R9C1#1}
C1#2 = {R1C1#2, R2C1#2, R3C1#2, R4C1#2, R5C1#2, R6C1#2, R7C1#2, R8C1#2, R9C1#2}
...
C9#9 = {R1C9#9, R2C9#9, R3C9#9, R4C9#9, R5C9#9, R6C9#9, R7C9#9, R8C9#9, R9C9#9}

Anche qui, come nel caso precedente definiamo i valori potenziali che si candidano a soddisfare le coppie colonna/valore.

Per ogni riga una cifra può comparire una sola volta:

Ripetiamo lo stesso ragionamento fatto per le colonne stavolta per le righe:

R1#1 = {R1C1#1, R1C2#1, R1C3#1, R1C4#1, R1C5#1, R1C6#1, R1C7#1, R1C8#1, R1C9#1}
R1#2 = {R1C1#2, R1C2#2, R1C3#2, R1C4#2, R1C5#2, R1C6#2, R1C7#2, R1C8#2, R1C9#2}
...
R9#9 = {R9C1#9, R9C2#9, R9C3#9, R9C4#9, R9C5#9, R9C6#9, R9C7#9, R9C8#9, R9C9#9}

In ognuno dei 9 box 3×3 ogni cifra può comparire una sola volta:

Il ragionamento è di nuovo lo stesso ma questa volta elenchiamo i valori potenziali per ogni coppia (box/valore); chiamiamo il box con la sintassi B1..B9:

B1#1 = {R1C1#1, R1C2#1, R1C3#1, R2C1#1, R2C2#1, R2C3#1, R3C1#1, R3C2#1, R3C3#1}
B1#2 = {R1C1#2, R1C2#2, R1C3#2, R2C1#2, R2C2#2, R2C3#2, R3C1#2, R3C2#2, R3C3#2}
...
B9#9 = {R7C7#9, R7C8#9, R7C9#9, R8C7#9, R8C8#9, R8C9#9, R9C7#9, R9C8#9, R9C9#9}

Conclusioni (per questo episodio):

Se proviamo a fare due conti scopriremo che abbiamo definito 81(cella/valori) + 81(colonna/valore) + 81(riga/valore) + 81(box/valore) = 81 x 4 = 324 vincoli. Ognuno di questi vincoli coinvolge 9 valori potenziali quindi per ogni valore potenziale esistono sempre 4 vincoli.

E’ possibile rappresentare tutti questi vincoli in una matrice che riporti sulle colonne i suddetti vincoli (quindi R1C1..R9C9,C1#1..C9#9,R1#1..R9#9,B1#1..B9#9) e sulle righe tutti i valori potenziali (R1C1#1..R9C9#9). Ad ogni cella di questa matrice si andrà poi ad inserire un 1 nel caso che il vincolo specificato incida sul valore potenziale ed uno zero altrimenti.

Bob Hanson ha creato e pubblicato la matrice completa.

Nel prossimo capitolo (che spero vivamente di postare tra sette giorni) scopriremo come risolvere un Sudoku, e – cosa importante – accertarci che tale soluzione sia univoca, usando la tecnica dei Dancing Links.

Sandro