Ideas de diseño de Sudoku y soluciones completas

Primeras palabras: este programa aún no es estable y, a veces, se producen errores de tiempo de ejecución. El seguimiento se debe al método size() del vector. La depuración encontró que el min_seq en el medio no cambió exactamente como pretendía el autor.

Cuando se ejecute, si se produce un error, ejecútelo repetidamente. Si la ejecución tiene éxito, aparecerá una matriz de Sudoku de 9*9 correcta.

Si quieres jugar a un juego que ya tiene algunos números, simplemente modifica la matriz inicial.

Algoritmo: Define un conjunto de elementos opcionales para cada posición. Cada actualización elimina del conjunto los elementos que han aparecido en la fila, columna y matriz cuadrada de 3×3. Al completar, seleccione uno del conjunto mínimo de candidatos (se puede completar en cualquier momento), actualice el conjunto de candidatos y luego complete hasta que se cubran todas las posiciones y el juego finalice.

/*******Programa informático para juego de Sudoku 9×9*******/

/*********** *Autor: xiaocui ******************/

/******Hora: 2006.6.23******** ******** *****/

/******Versión: v1.0****************** *******/

/******Pensamiento algorítmico************************/

/*** ***Para el elemento en cada posición, considere el conjunto de números que se pueden seleccionar

y llene la posición con el menor número de elementos candidatos cada vez.

del conjunto mínimo de candidatos Seleccione aleatoriamente un elemento para completar y repita

este proceso hasta que todos los elementos estén completos************/

/****El relleno es aplicable Cuadrados de Sudoku completamente vacíos y cuadrados de Sudoku llenos con algunos números*****/

/****La primera actualización del conjunto de candidatos inicializado es precisamente resolver el juego Sudoku Tipo 2***/

/****Para aquellos que hayan completado algunos elementos, simplemente modifiquen la matriz MATRIX directamente*****/

/* ***Hay más de un resultado para el juego de Sudoku********/

#include

#include

#include

usando el espacio de nombres std;

/************Matriz inicial de 9×9** ********** ****/

/****** el elemento es 0, lo que indica que el puesto no se ha cubierto ***/

int MATRIX[9][9]={ {0,0,0,0,0,0,0,0,0},

{0,0,0,0,0, 0,0,0,0},

{0,0,0,0,0,0,0,0,0},

{0,0,0, 0,0,0,0,0,0} ,

{0,0,0,0,0,0,0,0,0},

{0, 0,0,0,0,0,0, 0,0},

{0,0,0,0,0,0,0,0,0},

{0,0,0,0,0, 0,0,0,0},

{0,0,0,0,0,0,0,0,0} }; /p>

/***** **Número de elementos dado inicialmente**********/

int INITIAL_COUNT

/** ******Número de elementos rellenos, como marca final de relleno*********/

int FINISH_COUNT=0

/****; ****El valor inicial de cada elemento Conjunto candidato *******/

vector > IVEC(81

/***); ************* *Prototipo de función****************/

/********* ***Obtener el número de elementos dado inicialmente*** ****/

int get_initialcount()

/******Candidato de inicialización

Colección******************/

void initial_candidate()

/********** ********from vector Eliminar el elemento especificado en *******/

void delete_value(vector &ivec,int value

); /*******Actualizar colección de candidatos ******************/

void refresco_candidate()

/******** devuelve 9×9 candidatos El número de secuencia del conjunto de candidatos con la menor cantidad de elementos del conjunto*******/

int min_seq()

/********genera aleatoriamente un número de secuencia de posición y lo obtiene El valor del elemento correspondiente al número de serie******/

int select_seq(int min_seq

/*******Rellene el elemento y determine si se debe completar. Terminado*******/

int is_finish(int min_seq, int); elegir_valor);

int main()

{

/******Obtener el número de elementos dado inicialmente*****/

INITIAL_COUNT=get_initialcount();

/***** *Inicializar el conjunto de candidatos*******/

inicial_candidate(); /p>

/********Actualice primero el conjunto de candidatos (para hacer frente al hecho de que parte del número se ha completado)*****/

actualizar_candidato();

int i

int MinSeq

int ElegirValue

MinSeq=min_seq(); /p>

ChooseValue=choose_seq(MinSeq);

while(is_finish(MinSeq,ChooseValue)!=1)

{

refresco_candidate()

MinSeq=min_seq();

ChooseValue=choose_seq(MinSeq)

}

/****** ****Envíe los resultados del juego de Sudoku completos*********/

for( i=0; i<9;++i)

{

for(int j=0;j<9;++j)

{

cout<

}

cout<

}

devuelve 0; p>}

/************************Definición de función***** ********** ********/

/************Obtener el número de elementos dado inicialmente****** */

int get_initialcount()

{

int count=0

for(int i=0;i<9 ;++i)

{

for(int j=0;j<

9;++j)

{

if(MATRIX[i][j]!=0)

{

cuenta++

}

}

}

recuento de devoluciones

}

/************Inicializar colección de candidatos******************/

void initial_candidate()

{

para(int i=0;i<81;++i)

{

para(int j=1;j< 10;++j)

{

IVEC[i].push_back(j);

}

}

}

/**********Eliminar el elemento especificado del vector**********/

void eliminar_valor(vector &ivec,int valor)

{

/************Si ivec está vacío, salga directamente**** ******/

if ( ivec.size()==0)

{

return

}

vector::iterador iter= ivec.begin();

while( iter

{

iter++;

}

if(iter

{

ivec.erase(iter

}

}

/***); *****Actualizar conjunto de candidatos****** ********/

void refresco_candidate()

{

int i;

int rownum,colnum;

int row,col

/******actualización 81 vector******* ***/

for(i=0 ;i<81;++i)

{

fila=i/9;

col=i%9;

if(MATRIX[row][col]!=0)//Esta posición ha sido ocupada

{

if(IVEC[i].size()!=0)// El vector no está vacío

{

/********Eliminar todo el candidato establecer******************/

IVEC[i].erase(IVEC[i].begin(),IVEC[i].end( ));

}

}

else

{

/*****Eliminar elementos en la misma fila****/

for(colnum=0;colnum<9; ++colnum)

{