Codifica efficiente di puzzle di sudoku

La specifica di qualsiasi griglia 9x9 arbitraria richiede di indicare la posizione e il valore di ciascun quadrato. Una codifica ingenua per questo potrebbe dare 81 triplette (x, y, valore), che richiedono 4 bit per ogni x, y e valore (1-9 = 9 valori = 4 bit) per un totale di 81x4x3 = 972 bit. Numerando ogni quadrato, è possibile ridurre le informazioni sulla posizione a 7 bit, facendo cadere un bit per ogni quadrato e un totale di 891 bit. Specificando un ordine predeterminato, è possibile ridurlo in modo più drastico a soli 4 bit per ciascun valore per un totale di 324 bit. Tuttavia, un sudoku può avere numeri mancanti. Ciò fornisce il potenziale per ridurre il numero di numeri che devono essere specificati, ma può richiedere bit aggiuntivi per indicare le posizioni. Usando la nostra codifica a 11 bit di (posizione, valore), possiamo specificare un puzzle con indizi con $n$ $11n$ bit, ad esempio un puzzle minimo (17) richiede 187 bit. La migliore codifica a cui ho pensato finora è usare un bit per ogni spazio per indicare se è pieno e, in tal caso, i 4 bit seguenti codificano il numero. Ciò richiede bit, 149 per un puzzle minimo ( ). Esiste una codifica più efficiente, preferibilmente senza un database di ciascuna configurazione di sudoku valida? (Punti bonus per affrontare un puzzle generale da ) $81+4n$ $n=17$ $n$ $N \times N$

Mi è appena venuto in mente che molti enigmi saranno una rotazione di un altro o avranno una semplice permutazione delle cifre. Forse questo potrebbe aiutare a ridurre i bit richiesti.

Secondo Wikipedia ,

Il numero di griglie classiche della soluzione Sudoku 9 × 9 è 6.670.903.752.021.072.936.960 (sequenza A107739 in OEIS), o circa . $6.67×10^{21}$

Se avessi fatto bene la mia matematica ( ), ciò avrebbe prodotto 73 (72.498) bit di informazioni per una tabella di ricerca. $\frac{ln{(6,670,903,752,021,072,936,960)}}{ln{(2)}}$

Ma:

Il numero di soluzioni essenzialmente diverse, quando si tiene conto delle simmetrie come rotazione, riflessione, permutazione e rietichettatura, è stato mostrato essere solo 5.472.730.538 [15] (sequenza A109741 in OEIS).

Ciò fornisce 33 (32.35) bit, quindi è possibile che un metodo intelligente per indicare quale permutazione usare possa scendere sotto i 73 bit completi.

— Kevin
fonte

Ah, inizialmente ho pubblicato alcune cose senza pensare abbastanza al problema. L'ho cancellato Ottima domanda!

— Patrick87

Puoi ricordarci quanti enigmi del Sudoku ci sono, quindi sappiamo quanto è ampio il divario tra queste codifiche facilmente decodificabili e un elenco di forza bruta?

— Gilles 'SO-smetti di essere malvagio' il

Devi essere in grado di codificare tutti

6.67 \times 10^{21}

$6.67 \times 10^{21}$ griglie , quindi hai bisogno di 73 bit (assumendo la codifica a lunghezza fissa). Nessun "metodo intelligente per indicare quale permutazione usare" ti aiuterà in questo.

— svick

@sick Dal punto di vista della teoria dell'informazione, penso che tu debba avere ragione, ma non riesco a capire da dove provengano i bit extra. Ce ne sonole permutazioni, che sono 19 bit, più 3 per specchio e rotazione, quindi 22 più 33 per puzzle unici, ne fanno 55; da dove vengono gli altri 18?

9!

$9!$

— Kevin

Vedi Qual è il numero minimo di bit necessari per memorizzare un puzzle di Sudoku?

— Kaveh

Esiste una codifica più efficiente, preferibilmente senza un database di ciascuna configurazione di sudoku valida?

Sì. Mi viene in mente una codifica che migliora la tua codifica a 149 bit di un minimopuzzle in 6 o 9 bit, a seconda di una condizione. Questo èsenzaun database o alcun registro di altre soluzioni o schede parziali. Eccolo: $9\times 9$

Innanzitutto, si utilizzano bit per codificare un numero con un numero minimo di aspetti nella scheda. I successivi bit codificano il numero effettivo di volte che appare . Il prossimo $4$ $m$ $4$ $\ell$ $m$ bit codificano ciascuna delle posizioni in cuiappare . $7\ell$ $m$

I seguenti bit sono flag che indicano se le posizioni rimanenti hanno un numero o meno (si salta semplicemente la posizione in cui si trova ). Ogni volta che uno di questi bit è , i successivi 3 bit indicano quale numero è (nell'insieme ordinato senza ). Ad esempio, se e 3 bit sono , allora il numero nella posizione corrispondente sulla scheda è il 5 (contando da 0) nel set $81-\ell$ $m$ 1 $\{1,\ldots,9\}$ $m$ $m=4$ 101 , quindi è . I numeri saranno codificati in binario come , mentre i numeri saranno codificati come . Dato che avevamo già scritto posizioni,verranno aggiuntisolo bit per codificare il resto della scheda in questo passaggio. $\{1,2,3,5,6,7,8,9\}$ $6$ $j<m$ $j-1$ $j>m$ $j-2$ $\ell$ $3(n-\ell)$

Pertanto, il numero totale di bit richiesti per codificare una scheda usando questa procedura è

B = 4 + 4 + 7 ℓ + (81 - ℓ) + 3 (n - ℓ) = 89 + 3 ℓ + 3 n .

$B=4+4+7\ell+(81-\ell)+3(n-\ell)=89+3\ell+3n.$

Per , notiamo che può essere 0 o 1 (in generale, $n=17$ $\ell$ ). Pertanto, può essere 140 o 143 a seconda che non ci sia un numero che non appare sul tabellone. $\ell\leq\lfloor n/9\rfloor$ $B$

Vale la pena sottolineare che la soluzione di Kevin è molto meglio nel caso generale. Questa codifica utilizza al massimo 149 bit solo per o per condizione che . Almeno mostra un'idea generale su come trarre vantaggio dal fatto che è molto vicino a $n\in\{17,18,19\}$ $n=20$ $\ell=0$ $N=9$ $2^{\lfloor\log_2N\rfloor}$ (il che significa che tendiamo a "perdere memoria" usando 4 bit per valore, poiché 4 bit consentono anche per esprimere numeri. $N=16$

Esempio. Considera la seguente scheda con indizi. $n=17$

.  .  .   .  .  .   .  1  .
4  .  .   .  .  .   .  .  .
.  2  .   .  .  .   .  .  .

.  .  .   .  5  .   4  .  7
.  .  8   .  .  .   3  .  .
.  .  1   .  9  .   .  .  .

3  .  .   4  .  .   2  .  .
.  5  .   1  .  .   .  .  .
.  .  .   8  .  6   .  .  .

Qui, nessun numero non appare sul tabellone e i numeri 6, 7 e 9 appaiono solo una volta. Prendiamo ( ) e ( ). Leggendo le posizioni da sinistra a destra e poi dall'alto verso il basso, appare nella posizione ( ). Pertanto, la nostra codifica inizia con . $m=7$ 0111 $\ell=1$ 0001 $m$ $36$ 0100100011100010100100

Successivamente, abbiamo bisogno di sette 0s, uno 1e la codifica a 3 bit del numero , quindi a seguita da a e la codifica a 3 bit di , ecc. ( ). Alla fine, salteremo la posizione in cui è e codificheremo 8 come (il sesto numero conta da 0 nell'elenco $1$ 01 $4$ 0000000100101100 $m=7$ 110 ) e 9 come. La codifica completa è la seguente: ${1,2,3,4,5,6,8,9}$ 111

// m=7, l=1 and its position on the board.
011100010100100
// Numbers 1 and 4 at the beginning. Note that 1 is encoded 000, and 4 is 011.
0000000100001011
// Numbers 2 and 5.
0000000001001000000000001100
// Numbers 4 and 8. We skip the appearance of 7 and encode 8 as 110.
010110001110
// 3, 1 and 9. 9 is encoded as 111.
00010100000100001111
// 3, 4, 2, 5, 1, 8, 6 and the last empty cells.
0000101000101100100100011000100000000000111001101000

La codifica completa è 01110001010010000000001001010110000000001001000000000001100010110001110000101000001000011110000101000101100100100011000100000000000111001101000e il lettore può verificare che la lunghezza di quella stringa sia davvero 143 :-)

— Janoma
fonte