Qual é o número mínimo de bits necessário para armazenar um quebra-cabeça sudoku?

Nota: trata-se do quebra-cabeça padrão do sudoku 9x9. A solução precisa apenas suportar quebra-cabeças legais resolvidos . Portanto, uma solução não precisa suportar células vazias e pode confiar nas propriedades de um quebra-cabeça sudoku resolvido.

Eu estava pensando isso, mas não conseguia pensar em uma resposta com a qual me contentasse. Uma solução ingênua usaria um byte para cada célula (81 células), totalizando 648 bits. Uma solução mais sofisticada armazenaria todo o quebra-cabeça do sudoku em um número de base 9 (um dígito por célula) e exigiria bits.$\lceil\log_2(9^{81}))\rceil = 257$

Mas ainda pode ser aprimorado, por exemplo, se você souber 8 dos 9 números em uma sub-grade 3x3, poderá deduzir trivialmente o 9º. Você pode continuar com esses pensamentos até o ponto em que essa pergunta se resume a Qual é a quantidade de sudokus resolvidos únicos? Agora você pode usar uma enorme tabela de pesquisa que mapeia cada número binário para um quebra-cabeça sudoku, mas isso não seria uma solução utilizável.

Então, minha pergunta:

Sem usar uma tabela de pesquisa, qual é a quantidade mínima de bits necessária para armazenar um quebra-cabeça sudoku e com qual algoritmo?

Na mesma linha da resposta da catraca, se você preencher as células não estreladas na matriz a seguir, uma caixa 3x3 de cada vez, sempre escolhendo a próxima caixa a ser preenchida por uma que compartilhe linhas ou colunas com uma caixa que você já preenchido, você obtém um padrão como o seguinte para o número de opções por etapa (preenchendo a caixa do meio superior primeiro, a caixa do canto superior direito, etc.).

Em cada caixa 3x3 após a primeira, depois de preencher uma linha ou coluna da caixa, três dos seis dígitos restantes são localizados em uma única linha. Escolha seus locais primeiro e preencha as três células restantes. (Portanto, a ordem real de quais células preencher pode variar dependendo do que você já sabe, mas o número de opções nunca é maior do que o que mostrei.)

Depois de preencher essas células, todas as estrelas são determinadas.

* * * 9 8 7 6 5 4
* * * 6 5 4 3 3 2
* * * 3 2 1 3 2 1

6 5 4 * * * 6 3 3
3 3 2 * * * 5 3 2
3 2 1 * * * 4 2 1

6 3 3 6 5 4 * * *
5 3 2 3 3 2 * * *
4 2 1 3 2 1 * * *

Se eu calculei corretamente, isso fornece 87 bits. Há algumas economias adicionais a serem obtidas no último bloco 3x3, de acordo com o comentário de Peter Shor: todo valor é localizado em uma das quatro células e cada linha contém pelo menos uma célula com apenas quatro valores possíveis, portanto, certamente os fatores nesse O bloco deve começar com 4 e não 6, mas não entendo os fatores restantes na resposta de Shor.

continuando com a resposta de @ Peter, aqui está uma lista de piores possibilidades para cada célula, à medida que você a preenche a partir do canto superior esquerdo

9   8   7       6   5   4       3   2   1
6   5   4       6   5   4       3   2   1
3   2   1       3   2   1       3   2   1

6   6   3       6   5   4       3   2   1
5   5   2       5   5   3       3   2   1
4   4   1       4   2   1       3   2   1

3   3   3       3   3   3       1   1   1
2   2   2       2   2   2       1   1   1
1   1   1       1   1   1       1   1   1

isso contribui para 4.24559E + 29 posibilidades ou 99 bits

editar: esqueceu que o último quadrado é totalmente determinado por todos os outros

Você não precisa de uma tabela de consulta completa para obter uma compressibilidade ideal. Acredito que os computadores modernos que usam uma tabela de consulta bastante razoável possam contar o número de Sudokus restritos , que são Sudokus com alguns dígitos já existentes. Usando isso, veja como você codifica (a decodificação é semelhante).

Corrija uma ordem dos quadrados. Suponha que o número no primeiro quadrado seja . Coloque N 1 como o número de Sudokus cujo primeiro quadrado é menor que d 1 . Seja agora d 2 o número do segundo quadrado. Coloque N 2 como o número de Sudokus cujo primeiro quadrado é d 1 e cujo segundo quadrado é menor que d 2 . E assim por diante. O número codificado é N = Σ i N i .$d_1$$N_1$$d_1$$d_2$$N_2$$d_1$$d_2$$N = \sum_i N_i$

Este método de codificação é conhecido como codificação binomial na literatura. Isso deve permitir que você efetivamente (no sentido do mundo real) calcule o índice de qualquer Sudoku e vice-versa. Você precisará de apenas bits, conforme mencionado acima (isso significa que você pode codificar vários deles com esse número médio de bits).$72.4$

Edit: A página da Wikipedia sobre matemática do Sudoku nos ajuda a esclarecer a imagem. Também é útil uma tabela compilada por Ed Russell .

Acontece que, se você considerar apenas as três principais linhas, haverá essencialmente apenas 44 configurações diferentes a serem consideradas. Na tabela, você pode encontrar o número total de configurações equivalente a qualquer uma delas (assumindo que a linha superior seja 123456789) e o número total de conclusões de cada uma. Dado um Sudoku, eis como calcularíamos seu número ordinal:

1. Normalize a configuração para que sua linha superior seja 123456789.
2. Descubra a quais das 44 configurações diferentes ela pertence. O artigo da Wikipedia fornece um algoritmo para isso. A tabela lista o número de classes de equivalência para cada configuração, bem como o número de conclusões.
3. Determine o número ordinal da configuração das três principais linhas dentro de sua classe de equivalência. Isso pode ser feito de duas maneiras: usando uma lista de toda a classe de equivalência (existem 36288 no total em todas as classes de equivalência) ou encontrando uma maneira de enumerar rapidamente todas elas.
4. Normalize as linhas restantes classificando as linhas 4-6 e 7-9 pela primeira coluna e, em seguida, classificando esses dois blocos de linhas de maneira arbitrária. Isso reduz o número de conclusões por um fator de 72.
5. $2^{20}$
6. $i$$j$$k$$C_i,D_i$$C_i + jD_i + k$$9! \cdot 72$

Este procedimento é reversível e gerará um Sudoku a partir de um número ordinal. Observe que a enumeração do Sudoku foi reduzida para alguns minutos (em 2006; veja a página de discussão do artigo da Wikipedia) ou menos; portanto, espero que em um computador moderno essa abordagem seja muito prática e demore alguns segundos ou menos.

Aqui está um algoritmo que eu suspeito que produzirá uma codificação muito boa. Você tem o sudoku finalizado que deseja compactar e digamos que já codificou algumas células dele, então há um sudoku parcial (não necessariamente com uma solução exclusiva) com algumas células preenchidas.

Use um algoritmo fixo para contar quantos números podem ser colocados em cada célula vazia. Encontre a primeira célula lexicograficamente na qual o menor número de números diferentes pode ser colocado e codifique qual desses números entra nela (portanto, se uma célula puder conter apenas 3, 7 ou 9, os 3 serão codificados por "0 ", o 7 por" 1 "e o 9 por" 2 "). Codifique a sequência resultante usando codificação aritmética (que leva em consideração o número de números possíveis que uma célula pode conter).

Não sei quanto tempo durará a sequência binária resultante, mas suspeito que seja muito curta, especialmente se o seu algoritmo para contar quantos números podem ser colocados em uma célula for razoavelmente sofisticado.

Se você tivesse um bom algoritmo que estimasse a probabilidade de cada célula contendo um determinado número, poderia fazer ainda melhor.

Comentários e críticas são bem-vindos

$69.96$$171.72$

1.) Armazenar o quebra-cabeça implica armazenar a solução (informações teoricamente).

$t(\alpha)\alpha^{2}$$t(\alpha)$$\alpha$$t(3) ~= 2.44444$$3$

$P$$\alpha^{4}$$t(\alpha)\alpha^{2}$

$M$$\beta \times \alpha^{4}$$\beta \ge 2t(\alpha)\alpha^{2}$$2t(\alpha)\alpha^{2}$$\{0,\pm 1\}$$\beta = kt(\alpha)\alpha^{2}$$k$

$V = MP$$\beta$$|\alpha^{2}|$$M$$\{0,\pm 1\}$

$V$$\beta\log{\alpha^{2}} = 2kt(\alpha)\alpha^{2}\log{\alpha}$

$\alpha = 3$$t(\alpha) ~= 3$$2kt(\alpha)\alpha^{2}\log{\alpha} = 69.96k$$85.86k$$k=2$$139.92$$171.72bits$

$MP$

$A.)$$k$$2$$t(\alpha)-1$

$B.)$$t(\alpha)$$t(\alpha)$$k$$t(\alpha)$${}^{\alpha^{4}}C_{t(\alpha)\alpha^{2}}$${}^{\alpha^{4}-(3\alpha^{2} - 1)}C_{t(\alpha)\alpha^{2}-3t(\alpha)}$

$t(\alpha)\alpha^{2}$

$C.)$$k$

$D.)$ $V$$V$$O(\sqrt(V_{max})) = O(\sqrt{|\alpha^{2}|})$$2$$\beta\log{\alpha^{2}} = 2kt(\alpha)\alpha^{2}\log{\alpha}$

$2k$$2$$A.)$$B.)$$C.)$$D.)$$89$$73$

Isso é para relatar uma implementação da codificação compacta completa do sudoku (semelhante à sugestão de Zurui Wang 14/09/11).

A entrada é a linha superior e os 3 primeiros dígitos da 2ª linha. Estes são reduzidos para 1-9! e 1-120 e combinados com <= 4,4x10 ^ 7. Eles são usados ​​como dados para contar lexicograficamente todos os sukokus parciais de 30 dígitos até a sequência correspondente. A contagem final até os 81 dígitos inteiros é feita da mesma maneira. Essas três sequências são armazenadas como números inteiros de 32 bits, com no máximo 26 bits, para que possam ser compactadas ainda mais. Todo o processo leva cerca de 3 minutos, com os primeiros 30 dígitos levando a maior parte do tempo. A decodificação é semelhante - exceto as contagens correspondentes, em vez do sudokus.

Em breve - a revisão inclui os 3 primeiros dígitos da 2ª linha na enumeração de 30 dígitos (código de 2 bits), comparações com a enumeração Jarvis (Jscott, 3/1615)

Eu iria com a seguinte análise simples:

Cada valor pode ser armazenado em 4 bits (varia de 1 a 9, esses três bits permitem até 0 a 16)

$9 \times 9 = 81$

$8 \times 8$

Eu acho que eu poderia reduzi-lo para:

$b = \lceil \log_2(v) \rceil (n-1)$

Onde

$v$

$n$

Edit: Neo Style: Conheço Latex.

Esse número é diferente para cada Sudoku. Uma das regras do Sudoku é que ele tem exatamente uma solução.

Portanto, se você olhar um exemplo, é a quantidade mínima de dados que você deve armazenar.

Se você trabalha do lado oposto, pode remover dígito por dígito e executar um solucionador no resultado para ver se ele ainda possui exatamente uma solução. Nesse caso, você pode excluir outro dígito. Caso contrário, você deve restaurar esse dígito e tentar outro. Se você não pode, você encontrou um mínimo.

Como a maioria dos quebra-cabeças começa quase vazia, uma codificação de duração da execução provavelmente produzirá bons resultados.