El matemático finlandés Inkara pasó tres meses diseñando el Sudoku más difícil del mundo y solo tiene una respuesta. Inkara dijo que sólo los pensadores más rápidos y las mentes más brillantes pueden descifrar el juego.
Hoy, una noticia de Tencent decía que un anciano chino descifró la cuadrícula de nueve cuadrados más difícil del mundo en tres días. Aunque al final el anciano cambió un número, despertó mi interés y quiso resolver el problema a través de un. programa de computadora, así que me quedé en el dormitorio por una tarde y finalmente lo resolví con éxito, el código fuente del programa es el siguiente.
Copie el código de código de la siguiente manera:
número de paqueteJuego;
Punto de clase pública {
col privada int;//número de línea
fila int privada;//número de columna
bandera booleana privada; // Verdadero no está establecido.
valor int privado;
//Punto de construcción
Punto público (int col, int fila, bandera booleana, valor int) {
súper();
this.col = col;
this.fila = fila;
this.flag = bandera;
this.value = valor;
}
bandera de cambio pública vacía() {
bandera = !bandera;
}
getFlag público booleano() {
bandera de retorno;
}
público int getValue() {
valor de retorno;
}
setValue público vacío (valor int) {
this.value = valor;
}
public boolean canHere(Punto[][] pArr) {
booleano cb = canCol(pArr);
booleano cr = canRow(pArr);
booleano cminiArr = canMiniArr(pArr);
devolver cb && cr && cminiArr;
}
//Juzga si hay los mismos elementos en la pequeña cuadrícula de 3*3
canMiniArr booleano privado (Punto [][] pArr) {
int coltemp = this.col % 3;
int rowtemp = this.row % 3;
for (int i = this.col - coltemp; i < col + (3 - coltemp); i++) {
for (int j = this.row - rowtemp; j < fila + (3 - rowtemp); j++) {
if(i == esta.col && j == esta.fila){
continuar;
}demás{
if(este.valor == pArr[i][j].getValue()){
devolver falso;
}
}
}
}
devolver verdadero;
}
// Determinar si hay los mismos elementos en la columna
canRow booleano privado(Punto[][] pArr) {
para (int i = 0; i < 9; i++) {
si (i == esto.col) {
continuar;
} demás {
if (this.value == pArr[i][this.row].value) {//La fila cambia, la columna permanece sin cambios
devolver falso;
}
}
}
devolver verdadero;
}
// Determinar si hay los mismos elementos en la fila
canCol booleano privado(Punto[][] pArr) {
para (int i = 0; i < 9; i++) {
si (i == esta.fila) {
continuar;
} demás {
if (this.value == pArr[this.col][i].value) {//Bordes de columna, filas sin cambios
devolver falso;
}
}
}
devolver verdadero;
}
}
―El código de copia del programa principal es el siguiente:
número de paqueteJuego;
importar java.io.BufferedReader;
importar java.io.IOException;
importar java.io.InputStreamReader;
importar java.util.ArrayList;
clase pública Número99 {
public static void main (String [] args) lanza IOException {
Punto[][] numMat = nuevo Punto[9][9];
ArrayList<Punto> al = new ArrayList<Punto>();
initNumMat(numMat,al);
setNum(numMat,al);
printMat(numMat);
}
conjunto de vacío estático privadoNum(Point[][] numMat,ArrayList<Point> al) {
int yo = 0;
int j = 0;
hacer{
si (numMat[i][j].getFlag()) {
for (int v = numMat[i][j].getValue()+1; v <= 9; v++) {// Añade uno al valor de la posición devuelta.
numMat[i][j].setValue(v);
if (numMat[i][j].canHere(numMat)) {//Se cumplen las condiciones y no hay conflicto.
numMat[i][j].changeFlag();//Cambia el indicador a falso. Indica que se ha configurado.
romper;
}else{//No satisface ninguna condición, entra en conflicto. El valor del valor se incrementa una vez.
}
while(v == 9){// Si 1-9 no puede cumplir con los requisitos, primero restablezca la posición de inicio a 0, retroceda un espacio y agregue uno al valor de la posición devuelta (cuando la posición devuelta sea Cuando el valor no es 9, se garantiza que la posición a la que se regresa no es el punto original de la cuadrícula de Jiugong).
numMat[i][j].setValue(0);
j--;
si(j==-1){
i--;j=8;
}
while(al.contains(numMat[i][j])){// Si la posición a la que se regresa es el punto original de la cuadrícula de Jiugong, continúa retrocediendo hasta que no sea el propio punto y salta fuera del while.
j--;
si(j==-1){
i--;j=8;
}
}
numMat[i][j].changeFlag();//Marcará
v = numMat[i][j].getValue();
}
}
}
j++;
si(j==9){
j=0;i++;//i++ aquí puede hacer que i aumente a 9, por lo que el siguiente juicio requiere i!=9
}
si(yo!=9){
while(al.contiene(numMat[i][j])){
j++;
si(j==9){
j=0;i++;
}
}
}
}mientras(i!=9);
}
public static void initNumMat(Point[][] numMat,ArrayList<Point> al) lanza IOException {
para (int i = 0; i < numMat.length; i++) {
for (int j = 0; j < numMat[i].length; j++) {
numMat[i][j] = nuevo punto(i, j, verdadero, 0);
}
}
initNumMat2(numMat, al);
}
public static void initNumMat2(Point[][] numMat, ArrayList<Point> al) lanza IOException {
BufferedReader br = nuevo BufferedReader (nuevo InputStreamReader (System.in));
Cadena[] p = nueva Cadena[3];
Línea de cadena = nula;
System.out.println ("Ingrese la información del punto de acuerdo con el formato (número de fila i, número de columna j y valor v), ingrese: ijv ");
while((línea = br.readLine())!=null){
si(linea.equals("sobre"))
romper;
p = línea.trim().split(" +");
numMat[Integer.parseInt(p[0])][Integer.parseInt(p[1])].setValue(Integer.parseInt(p[2]));
numMat[Integer.parseInt(p[0])][Integer.parseInt(p[1])].changeFlag();
al.add(numMat[Integer.parseInt(p[0])][Integer.parseInt(p[1])]);
}
}
printMat vacío estático público (Punto [][] numMat) {
System.out.println("--------┬---------┬---------┐");
para (int i = 0; i < numMat.length; i++) {
for (int j = 0; j < numMat[i].length; j++) {
si ((j + 1) % 3 == 0)
System.out.print(numMat[i][j].getValue() + " | ");
demás
System.out.print(numMat[i][j].getValue() + " ");
}
si ((yo + 1) % 3 == 0)
System.out.println("/r/n--------┼---------┼---------┤");
demás
System.out.println();
}
}
}
---Ejecutar el programa
Ingrese la información del punto de acuerdo con el formato (i número de fila, j número de columna y valor v) e ingrese: ijv al ingresar.
0 0 8
1 2 3
1 3 6
2 1 7
2 4 9
2 6 2
3 1 5
3 5 7
4 4 4
4 5 5
4 6 7
5 3 1
5 7 3
6 2 1
6 7 6
6 8 8
7 2 8
7 3 5
7 7 1
8 1 9
8 6 4
encima
――┬―――┬―――┐
8 1 2 | 7 5 3 |
9 4 3 | 6 8 2 |
6 7 5 | 4 9 1 |
――┼―――┼―――┤
1 5 4 | 2 3 7 |
3 6 9 | 8 4 5 |
2 8 7 | 1 6 9 |
――┼―――┼―――┤
5 2 1 | 9 7 4 |
4 3 8 | 5 2 6 |
7 9 6 | 3 1 8 |
――┼―――┼―――┤