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

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.