Código fuente del sudoku
# 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 p>
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) { p>
//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 }
p>
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};
p>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)
p>
{
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
{ p>
bool bBack
testBackOpt(): bBack(false){}
operador void () (Artículo y elemento de amplificador)
{ p>
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 }
p>
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};
p>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)
p>
{
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
{ p>
bool bBack
testBackOpt(): bBack(false){}
operador void () (Artículo y elemento de amplificador)
{ p>
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;