Red de conocimiento informático - Conocimiento de la instalación - Código fuente del sudoku

Código fuente del sudoku

No lo he probado

# include ltstdio.h gt

# include ltstdlib.h gt

int Sudoku[81] //Sudoku problem array

int tempNum[81]; //Última posición llena

int tempSp = 0; //Indicador de posición del último número lleno

int startH[81] ; //El punto inicial de la posición de la columna

int startV[81]; //El punto inicial de la posición de la fila

int startB[81]; de la posición de la cuadrícula de nueve cuadrados

int addH[9] //Incremento de la posición de la columna

int addV[9] //Incremento de la posición de la fila

int addB[9]; // bonificación de posición de Jiugongge

int main(int argc, char *argv[]) {

int j;

if(argc gt; 1)for(j = 0; j lt81; j ) Sudoku[j]= argv[1][j]--0;

De lo contrario, salga

printf("-\ n ");

printSudoku(Sudoku);

init(); //Configuración de parámetros

tryAns(); ; //Probar solución

printf("-\ n ");

printSudoku(Sudoku);

printf("-\ n ");

}

int init() {

//Configuración de parámetros (después de configurar estos parámetros, será mucho más conveniente verificar filas, columnas y cuadrículas )

int I;

for(I = 0;ilt81;i) {

startH[I]= I/9 * 9; de la posición de la columna

startV[I]= I 9; //Inicio de la posición de la línea

startB[I]=((I/9)/3)* 27 ((I 9)/3)* 3; //El punto inicial de la posición de la cuadrícula de nueve cuadrados

}

for(I = 0; Ilt9; i) {

addH[I]= I; //Incremento de posición de columna

addV[I]= I * 9; //Incremento de posición de fila

addB[I]= (I/3)* 9 (I 3) ; //Bonificación de posición de Jiugongge

}

int printSudoku(int *prn) {

//Imprimir problema de Sudoku (contenido de la matriz)

int I;

for(I = 0;ilt81;i) {

printf ( "2d ", prn[I] );

if(I 9 = = 8)printf(" \ n ");

}

int tryAns () {

//Solución de prueba

int sp = get next blank(-1); //Obtiene la primera posición en blanco y comienza. completando números.

Hacer {

Sudoku [sp]; //Agrega 1 a este número de posición.

if(sudoku[sp] gt; 9) {//Si el número en esta posición es mayor que 9, regresa a la posición anterior para continuar con la prueba.

Sudoku [sp] = 0

sp = pop();

} En caso contrario {

If(check(sp ) ==0) {//Si no hay números idénticos en la misma fila, columna o cuadrícula, pasa al siguiente espacio.

Push(sp); //Por supuesto, si se encuentra el mismo número, es necesario agregar 1 al número original (por lo que no se hace nada aquí).

sp = obtener el siguiente espacio en blanco(sp);

}

} while(sp gt; = 0 amp ampsp lt81 ) ;

}

int getNextBlank(int sp) {

//Obtener la siguiente posición vacía

Hacer {

sp;

} while(sp lt; 81. amp Sudoku [sp] gt;

Retorno (sp); }

int check(int sp) {

//Comprueba si hay los mismos números en el par, la columna y la cuadrícula, y devuelve 1 si es así.

int fg = 0;

if (!fg) fg = check1(sp, startH[sp], addH); // Comprobar si hay los mismos números en el mismo. columna.

if (!fg) fg = check1(sp, startV[sp], addV); // Comprobar si el par tiene el mismo número.

If (!fg) fg= check1(sp, startB[sp], addB); //Comprueba si existe el mismo número que la cuadrícula de nueve cuadrados.

Retorno (fg);

}

int check1(int sp, int start, int *addnum) {

// Compruebe si las filas, columnas y cuadrados especificados tienen el mismo número y, de ser así, devuelva 1.

int fg= 0,I,sp 1;

for(I = 0;ilt9;i) {

sp 1 = iniciar addnum[I ]

If (sp!=sp1. amp Sudoku[sp]= =Sudoku[sp 1])fg;

}

Return ( fg);

}

int push(int sp) {

//Coloca la posición especificada en la pila.

tempNum[tempsp]= sp;

}

int pop() {

//Saca la posición anterior en el pila .

if(tempSp lt; 0) devuelve (-1);

else return(tempNum[-tempSp]); p>Referencias:

. net/viewthread.php? tid=189678. El algoritmo de página = 1 es el siguiente: Primero, construya una matriz de estructura de 9 * 9, lo que indica que los datos del tablero de ajedrez 0 significan en blanco y desconocido, y cada elemento de la estructura.

Una matriz que contiene del 1 al 9 como números alternativos.

Después de construir el tablero de ajedrez, elimine los números candidatos en cada posición en blanco por turno. Los números ya completados hasta el momento serán eliminados.

Si solo queda un número de candidato, el número de candidato se completará en los datos del tablero. El algoritmo se implementa en Function AI.

Cuando el algoritmo de inteligencia artificial no puede deducir el resultado, se utiliza el método de retroceso. Cuando encuentre un elemento con dos números opcionales, seleccione uno de ellos.

Continúe completando hasta que todo esté completo (completado); de lo contrario, no se podrá completar (no hay ningún elemento de reemplazo en la posición en blanco).

Si no puedes continuar rellenando, los datos originales son incorrectos. Complete otros datos directamente en la pizarra.

Este algoritmo está implementado en AdvanceAI.

De esta forma se pueden rellenar todos los elementos del tablero.

# incluir ltcstdio gt

# incluir ltvector gt

# incluir lt algoritmo gt

Enum { TAMAÑO = 81 }

Datos enteros sin signo [SIZE]={//Datos de tablero de ajedrez sin resolver

0, 9, 0, 0, 6, 0, 5, 4, 8,

4, 0, 3, 0, 8, 0, 9, 0, 0,

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

0, 5, 6, 3, 9, 0, 4, 0, 1,

1, 4, 0, 0, 5, 0, 2, 0, 0,

0, 0, 0, 0, 4, 1, 0, 0, 0,

0, 0, 0, 8, 2, 0, 6, 1, 0,

0, 0, 0, 0, 3, 0, 0, 0, 4,

5, 8, 0, 9, 1, 0, 0, 0, 0};

const int temp[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

Elemento de estructura

{

int datos;

STD:: vector lt; int gt otro;

Artículo(): datos(0), otro(temp, temp 9){ }

Operador booleano en línea ==(int x)

{

¿Devolver x == datos? true: false;

}

Operador de amplificador de elemento en línea = (const Item amp; src)

{

data = src. datos

other = src.other

Return (* this);

}

Proyecto integrado amoperator=( int x) {

datos = x;

std::copy(temp, temp sizeof(temp)/sizeof(temp[0]), otro . comenzar()

Return (* this);

};

Prueba no válida(tamaño x){

if( other.size() == 2 )

data = other[x];

}

Operador en línea int(){ return data;}

};

Información del grupo de estructura {

const int Grupo1, Grupo2, Grupo3

GroupInfo(int g1, int g2, int g3): Grupo1( g1), Grupo2( g2), Grupo3(g3){}

Operador booleano en línea = =(información del grupo y src){

return((grupo 1 | grupo 2 | grupo 3) & (src Grupo 1 | origen Grupo 2 |

Grupo3))? Verdadero: Falso;

}

};

InfoGrupo Grupo[TAMAÑO]={

información del grupo(1 lt; lt1, 1 lt; lt10, 1 lt; lt19), información de grupo (1 lt; lt1, 1 lt; lt11, 1 lt; lt19), información de grupo (1 lt; lt1, 1 lt; lt12, 1 lt; lt19), grupo info(1lt;lt1,1lt;lt13,1lt;lt20), información de grupo(1lt;lt1,1lt;lt14,1lt;lt20), información de grupo(1lt;lt1,1lt;lt15, 1 lt; lt20), información de grupo (1 lt; lt1, 1 lt; lt16, 1 lt; lt21), información del grupo (1 lt; lt1, 1 lt; lt17, 1 lt; lt21), información del grupo (1 lt; lt1, 1 lt; lt18, 1 lt; lt21),

información del grupo (1 lt; lt2, 1 lt; lt10, 1 lt; lt19), información del grupo (1 lt; lt2, 1 lt; lt11, 1 lt; lt19), información de grupo (1 lt; lt2, 1 lt; lt12, 1 lt; lt19), información de grupo (1 lt; lt2, 1 lt; lt13, 1 lt; lt20), información de grupo (1 lt; lt2, 1 lt; lt14 , 1 lt; lt20), información del grupo (1 lt; lt2, 1 lt; lt15, 1 lt; lt20), información del grupo (1 lt; lt2, 1 lt; lt16, 1 lt; lt21), información del grupo (1 lt ; lt2, 1 lt; lt17, 1 lt; lt21), información del grupo (1 lt; lt2, 1 lt; lt18, 1 lt; lt21),

información del grupo (1 lt; lt3, 1 lt) ; lt10, 1 lt; lt19), información del grupo (1 lt; lt3, 1 lt; lt11, 1 lt; lt19), información del grupo (1 lt; lt3, 1 lt; lt12, 1 lt; lt19), información del grupo ( 1 lt; lt3, 1 lt; lt13, 1 lt; lt20), información del grupo (1 lt; lt3, 1 lt; lt15, 1 lt ; lt20), información del grupo (1 lt; lt3, 1 lt; lt16, 1 lt; lt21), información del grupo (1 lt; lt3, 1 lt; lt17, 1 lt; lt21), información del grupo (1 lt; lt3, 1 lt; lt18, 1 lt; lt21),

información del grupo(1 lt; lt4, 1 lt; lt10, 1 lt;

lt22), información del grupo (1 lt; lt4, 1 lt; lt11, 1 lt; lt22), información del grupo (1 lt; lt4, 1 lt; lt12, 1 lt; lt22), información del grupo (1 lt; lt4, 1 lt; lt13, 1 lt; lt23), información del grupo (1 lt; lt4, 1 lt; lt14, 1 lt; lt23), información del grupo (1 lt; lt4, 1 lt; lt15, 1 lt; lt23), información del grupo (1 lt; lt4, 1 lt; lt16, 1 lt; lt24), información del grupo (1 lt; lt4, 1 lt; lt17, 1 lt; lt24), información del grupo (1 lt; lt4, 1 lt; lt18, 1 lt; lt24),

información del grupo(1 lt; lt5, 1 lt; lt10, 1 lt; lt22), información del grupo(1 lt; lt5, 1 lt; lt11, 1 lt; lt22), información de grupo (1 lt; lt5, 1 lt; lt12, 1 lt; lt22), información de grupo (1 lt; lt5, 1 lt; lt13, 1 lt; lt23), información de grupo (1 lt; lt5, 1 lt; lt14 , 1 lt; lt23), información del grupo (1 lt; lt5, 1 lt; lt15, 1 lt; lt23), información del grupo (1 lt; lt5, 1 lt; lt16, 1 lt; lt24), información del grupo (1 lt ; lt5, 1 lt; lt17, 1 lt; lt24), información del grupo (1 lt; lt5, 1 lt; lt18, 1 lt; lt24),

información del grupo (1 lt; lt6, 1 lt) ; lt10, 1 lt; lt22), información del grupo (1 lt; lt6, 1 lt; lt11, 1 lt; lt22), información del grupo (1 lt; lt6, 1 lt; lt12, 1 lt; lt22), información del grupo ( 1 lt; lt6, 1 lt; lt13, 1 lt; lt23), información del grupo (1 lt; lt6, 1 lt; lt15, 1 lt ; lt23), información del grupo (1 lt; lt6, 1 lt; lt16, 1 lt; lt24), información del grupo (1 lt; lt6, 1 lt; lt17, 1 lt; lt24), información del grupo (1 lt; lt6, 1lt; lt18, 1lt; lt24),

información del grupo(1lt; lt7, 1lt; lt10, 1lt; lt25), información del grupo(1lt; lt7, 1lt; lt11, 1lt; lt25), grupo info (1 lt; lt7, 1 lt; lt12, 1 lt; lt25), grupo

info(1lt;lt7,1lt;lt13,1lt;lt26), información de grupo(1lt;lt7,1lt;lt14,1lt;lt26), información de grupo(1lt;lt7,1lt;lt15, 1 lt; lt26), información de grupo (1 lt; lt7, 1 lt; lt16, 1 lt; lt27), información del grupo (1 lt; lt7, 1 lt; lt17, 1 lt; lt27), información del grupo (1 lt; lt7, 1 lt; lt18, 1 lt; lt27),

información del grupo (1 lt; lt8, 1 lt; lt10, 1 lt; lt25), información del grupo (1 lt; lt8, 1 lt; lt11, 1 lt; lt25), información de grupo (1 lt; lt8, 1 lt; lt12, 1 lt; lt25), información de grupo (1 lt; lt8, 1 lt; lt13, 1 lt; lt26), información de grupo (1 lt; lt8, 1 lt; lt14 , 1 lt; lt26), información del grupo (1 lt; lt8, 1 lt; lt15, 1 lt; lt26), información del grupo (1 lt; lt8, 1 lt; lt16, 1 lt; lt27), información del grupo (1 lt ; lt8, 1 lt; lt17, 1 lt; lt27), información del grupo (1 lt; lt8, 1 lt; lt18, 1 lt; lt27),

información del grupo (1 lt; lt9, 1 lt) ; lt10, 1 lt; lt25), información del grupo (1 lt; lt9, 1 lt; lt11, 1 lt; lt25), información del grupo (1 lt; lt9, 1 lt; lt12, 1 lt; lt25), información del grupo ( 1 lt; lt9, 1 lt; lt13, 1 lt; lt26), información del grupo (1 lt; lt9, 1 lt; lt15, 1 lt ; lt26), información del grupo (1 lt; lt9, 1 lt; lt16, 1 lt; lt27), información del grupo (1 lt; lt9, 1 lt; lt17, 1 lt; lt27), información del grupo (1lt; lt9,1lt ;lt18,1lt;lt27)

};

bool AI(std::vector lt;Item gt amp juego)

{

bool bMoveflag = false

for(size _ t x = 0; x ltgame . size(); x ){

if (0! =juego[x]. data ){//Compruebe cada ubicación por turno.

juego[x]. other . resize(0);

Continuar;

}

//No hay ningún número en la posición actual.

std: :vector lt; int gtvTemp

for(int i = 0; i lt81; i)

if(grupo[x] = = grupo [i])

vTemp.push_back (juego[i]). datos);

;

v temp . erase(STD::remove(v temp . begin(), vTemp.end(), v temp . end());

//Eliminar números que ya aparecen en el mismo grupo

for(STD:: vector lt; int gt* iterator Iter = v temp. comenzar(); Iter! = v. temp . end(); Iter)

STD::replace(juego[x]. otro . comenzar(), juego[x]. otro.end(), (*Iter), 0 );

juego[x]. otro. erase(STD::remove(juego[x]. otro. comenzar(), juego[x]. otro.end(), 0), juego[ x] . otro . end());

if((1 = = juego[x]. otro . tamaño()) amp; amp( 0 != juego[x]. otro[0] ) ) {

juego[x].data=juego[x].other[0];

bMoveflag = true

}

Devolver bMoveflag

}

Estructura OtherIs2Opt{

Operador booleano () (elemento y elemento de amplificador)

{return (item.other.size()==2)? true: false;}

};

Copia de seguridad de prueba de estructura

{

bool bBack

testBackOpt(): bBack(false){}

operador void () (Artículo y elemento de amplificador)

{

if((item . data == 0) amp; amp(item.other.size()==0))

bBack = true

}

};

bool advanced ai(STD::vector lt;Item gt amp juego)

{

STD ::vector lt ;Item gtBack = juego;

std::vector lt;Item gt::iterator iItem = std::find_if(Back.begin(), Back.end(), otro es 2 opt()) ;

si (iItem! = Back.end() ){

for(tamaño _ t I = 0; ilt(* iItem). other . tamaño(); i ){

(*iItem ) . Test(1);

for(;Ai(back););

If (STD:: for _ each (back.begin(), back.end(), pruebabackopt()).

bback){//¿Finalizar la reversión?

Back = juego;

iItem = std::find_if(Back.begin(), Back.end(), otro es 2 opt()); p>Continuar;

}

If (STD:: count (back.begin(), return.end(), 0)){//Determina si termina.

Si (AdvanceAI(Back)){//No finaliza, continúa con la siguiente recursión.

Juego=Volver;

Devuelve verdadero

}

Volver=Juego;

iItem = estándar: :find_if(Back.begin(), Back.end(), other es 2 opt());

Continuar;

}else{//back es el resultado.

juego=return;

devuelve verdadero

}

Devuelve falso

}

int main(int argc, char* argv[])

{//Inicializa el tablero de ajedrez

STD ::vector lt;Item gt juego(tamaño);

std::copia(Datos, TAMAÑO de datos, juego. comenzar());

for(;AI(juego ) ;);

if( std::count(game.begin(), game.end(), 0) ){

if (!AdvanceAI(juego))< / p>

Printf("Sin resolver");

}

for(int x = 0; x lt81; x){

printf( " d ", juego[x].data);

if( 0 == (x 1) 9)

printf(" ");

}

Devuelve 0; el algoritmo es el siguiente: primero construya una matriz de estructura de 9 * 9, que represente los datos del tablero de ajedrez. 0 significa que cada elemento de la estructura está en blanco y desconocido.

Una matriz que contiene del 1 al 9 como números alternativos.

Después de construir el tablero de ajedrez, elimine los números candidatos en cada posición en blanco por turno. Los números ya completados hasta el momento serán eliminados.

Si solo queda un número de candidato, el número de candidato se completará en los datos del tablero. El algoritmo se implementa en Function AI.

Cuando el algoritmo de inteligencia artificial no puede deducir el resultado, se utiliza el método de retroceso. Cuando encuentre un elemento con dos números opcionales, seleccione uno de ellos.

Continúe completando hasta que todo esté completo (completado); de lo contrario, no se podrá completar (no hay ningún elemento de reemplazo en la posición en blanco).

Si no puedes continuar rellenando, los datos originales son incorrectos. Complete otros datos directamente en la pizarra.

Este algoritmo está implementado en AdvanceAI.

De esta forma se pueden rellenar todos los elementos del tablero.

# incluir ltcstdio gt

# incluir ltvector gt

# incluir lt algoritmo gt

Enum { TAMAÑO = 81 }

Datos enteros sin signo [SIZE]={//Datos de tablero de ajedrez sin resolver

0, 9, 0, 0, 6, 0, 5, 4, 8,

4, 0, 3, 0, 8, 0, 9, 0, 0,

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

0, 5, 6, 3, 9, 0, 4, 0, 1,

1, 4, 0, 0, 5, 0, 2, 0, 0,

0, 0, 0, 0, 4, 1, 0, 0, 0,

0, 0, 0, 8, 2, 0, 6, 1, 0,

0, 0, 0, 0, 3, 0, 0, 0, 4,

5, 8, 0, 9, 1, 0, 0, 0, 0};

const int temp[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

Elemento de estructura

{

int datos;

STD:: vector lt; int gt otro;

Artículo(): datos(0), otro(temp, temp 9){ }

Operador booleano en línea ==(int x)

{

¿Devolver x == datos? true: false;

}

Operador de amplificador de elemento en línea = (const Item amp; src)

{

data = src. datos

other = src.other

Return (* this);

}

Proyecto integrado amoperator=( int x) {

datos = x;

std::copy(temp, temp sizeof(temp)/sizeof(temp[0]), otro . comenzar()

Return (* this);

};

Prueba no válida(tamaño x){

if( other.size() == 2 )

data = other[x];

}

Operador en línea int(){ return data;}

};

Información del grupo de estructura {

const int Grupo1, Grupo2, Grupo3

GroupInfo(int g1, int g2, int g3): Grupo1( g1), Grupo2( g2), Grupo3(g3){}

Operador booleano en línea = =(información del grupo y src){

return((grupo 1 | grupo 2 | grupo 3) & (src Grupo 1 | origen Grupo 2 |

Grupo3))? Verdadero: Falso;

}

};

InfoGrupo Grupo[TAMAÑO]={

información del grupo(1 lt; lt4, 1 lt; lt10, 1 lt;

información del grupo(1lt; lt7, 1lt; lt10, 1lt; lt25), información del grupo(1lt; lt7, 1lt; lt11, 1lt; lt25), grupo info (1 lt; lt7, 1 lt; lt12, 1 lt; lt25), grupo

};

bool AI(std::vector lt;Item gt amp juego)

{

bool bMoveflag = false

for(size _ t x = 0; x ltgame . size(); x ){

if (0! =juego[x]. data ){//Compruebe cada ubicación por turno.

juego[x]. other . resize(0);

Continuar;

}

//No hay ningún número en la posición actual.

std: :vector lt; int gtvTemp

for(int i = 0; i lt81; i)

if(grupo[x] = = grupo [i])

vTemp.push_back (juego[i]). datos);

;

v temp . erase(STD::remove(v temp . begin(), vTemp.end(), v temp . end());

//Eliminar números que ya aparecen en el mismo grupo

for(STD:: vector lt; int gt* iterator Iter = v temp. comenzar(); Iter! = v. temp . end(); Iter)

STD::replace(juego[x]. otro . comenzar(), juego[x]. otro.end(), (*Iter), 0 );

juego[x]. otro. erase(STD::remove(juego[x]. otro. comenzar(), juego[x]. otro.end(), 0), juego[ x] . otro . end());

if((1 = = juego[x]. otro . tamaño()) amp; amp( 0 != juego[x]. otro[0] ) ) {

juego[x].data=juego[x].other[0];

bMoveflag = true

}

Devolver bMoveflag

}

Estructura OtherIs2Opt{

Operador booleano () (elemento y elemento de amplificador)

{return (item.other.size()==2)? true: false;}

};

Copia de seguridad de prueba de estructura

{

bool bBack

testBackOpt(): bBack(false){}

operador void () (Artículo y elemento de amplificador)

{

if((item . data == 0) amp; amp(item.other.size()==0))

bBack = true

}

};

bool advanced ai(STD::vector lt;Item gt amp juego)

{

STD ::vector lt ;Item gtBack = juego;

std::vector lt;Item gt::iterator iItem = std::find_if(Back.begin(), Back.end(), otro es 2 opt()) ;

si (iItem! = Back.end() ){

for(tamaño _ t I = 0; ilt(* iItem). other . tamaño(); i ){

(*iItem ) . Test(1);

for(;Ai(back););

If (STD:: for _ each (back.begin(), back.end(), pruebabackopt()).

bback){//¿Finalizar la reversión?

Back = juego;

iItem = std::find_if(Back.begin(), Back.end(), otro es 2 opt()); p>Continuar;

}

If (STD:: count (back.begin(), return.end(), 0)){//Determina si termina.

Si (AdvanceAI(Back)){//No finaliza, continúa con la siguiente recursión.

Juego=Volver;

Devuelve verdadero

}

Volver=Juego;

iItem = estándar: :find_if(Back.begin(), Back.end(), other es 2 opt());

Continuar;

}else{//back es el resultado.

juego=return;

devuelve verdadero

}

Devuelve falso

}

int main(int argc, char* argv[])

{//Inicializa el tablero de ajedrez

STD ::vector lt;Item gt juego(tamaño);

std::copia(Datos, TAMAÑO de datos, juego. comenzar());

for(;AI(juego ) ;);

if( std::count(game.begin(), game.end(), 0) ){

if (!AdvanceAI(juego))< / p>

Printf("Sin resolver");

}

for(int x = 0; x lt81; x){

printf( " d ", juego[x].data);

if( 0 == (x 1) 9)

printf(" ");

}

Devuelve 0;

上篇: Cada vez que canceles Waga, la navegación del sitio web 568 aparecerá en el escritorio. 下篇: ¿Cuáles son los algoritmos utilizados en la planificación de rutas de robots móviles?

Código fuente del sudoku

Artículos populares