O matemático finlandês Inkara passou três meses projetando o quebra-cabeça de Sudoku mais difícil do mundo, e ele tem apenas uma resposta. Inkara disse que apenas os pensadores mais rápidos e as mentes mais brilhantes podem quebrar o jogo.
Hoje, uma notícia da Tencent dizia que um velho chinês quebrou a grade de nove quadrados mais difícil do mundo em três dias. Embora o velho tenha mudado um número no final, isso despertou meu interesse e quis resolver o problema por meio de um. programa de computador, então fiquei no dormitório por uma tarde e finalmente resolvi com sucesso, o código fonte do programa é o seguinte.
Copie o código do código da seguinte forma:
número do pacoteJogo;
classe pública Ponto {
private int col; // número da linha
private int row; // número da coluna
sinalizador booleano privado; // True não está definido.
valor interno privado;
//Ponto de construção
public Point(int col, int row, boolean flag, int value) {
super();
isto.col = col;
esta.linha = linha;
isto.flag = bandeira;
este.valor = valor;
}
public void changeFlag() {
bandeira = !bandeira;
}
public boolean getFlag() {
bandeira de retorno;
}
public int getValor() {
valor de retorno;
}
public void setValue(int valor) {
este.valor = valor;
}
public boolean canHere(Point[][] pArr) {
booleano cb = canCol(pArr);
booleano cr = canRow(pArr);
booleano cminiArr = canMiniArr(pArr);
return cb && cr && cminiArr;
}
//Julgue se existem os mesmos elementos na pequena grade 3*3
private boolean canMiniArr(Point[][] 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 < row + (3 - rowtemp); j++) {
if(i == isto.col && j == isto.linha){
continuar;
}outro{
if(este.valor == pArr[i][j].getValue()){
retornar falso;
}
}
}
}
retornar verdadeiro;
}
// Determina se existem os mesmos elementos na coluna
private boolean canRow(Ponto[][] pArr) {
for (int i = 0; i < 9; i++) {
if (i == this.col) {
continuar;
} outro {
if (this.value == pArr[i][this.row].value) {//A linha muda, a coluna permanece inalterada
retornar falso;
}
}
}
retornar verdadeiro;
}
// Determina se existem os mesmos elementos na linha
private boolean canCol(Ponto[][] pArr) {
for (int i = 0; i < 9; i++) {
if (i == this.row) {
continuar;
} outro {
if (this.value == pArr[this.col][i].value) {//Bordas da coluna, linhas inalteradas
retornar falso;
}
}
}
retornar verdadeiro;
}
}
―O código de cópia do programa principal é o seguinte:
número do pacoteJogo;
importar java.io.BufferedReader;
importar java.io.IOException;
importar java.io.InputStreamReader;
importar java.util.ArrayList;
classe pública Número99 {
public static void main(String[] args) lança IOException{
Ponto[][] numMat = new Ponto[9][9];
ArrayList<Ponto> al = new ArrayList<Ponto>();
initNumMat(numMat,al);
setNum(numMat,al);
printMat(numMat);
}
private static void setNum(Ponto[][] numMat,ArrayList<Ponto> al) {
int eu = 0;
int j = 0;
fazer{
if (numMat[i][j].getFlag()) {
for (int v = numMat[i][j].getValue()+1; v <= 9; v++) {//Adicione um ao valor da posição retornada.
numMat[i][j].setValue(v);
if (numMat[i][j].canHere(numMat)) {//As condições foram atendidas e não há conflito.
numMat[i][j].changeFlag();//Altera o sinalizador para falso. Indica que foi definido.
quebrar;
}else{//Não satisfaz nenhuma condição, conflito. O valor valor se incrementa uma vez
}
while(v == 9){//Se 1-9 não atender aos requisitos, redefina a posição inicial para 0 primeiro, volte um espaço e adicione um ao valor da posição retornada (quando a posição retornada for When o valor não é 9, é garantido que a posição retornada não é o ponto original da grade Jiugong).
numMat[i][j].setValue(0);
j--;
se(j==-1){
eu--;j=8;
}
while(al.contains(numMat[i][j])){//Se a posição retornada for o ponto original da grade Jiugong, continue recuando até que não seja o próprio ponto e pule para fora do while.
j--;
se(j==-1){
eu--;j=8;
}
}
numMat[i][j].changeFlag();//Marcará
v = numMat[i][j].getValue();
}
}
}
j++;
se(j==9){
j=0;i++;//i++ aqui pode fazer com que i aumente para 9, então o julgamento a seguir requer i!=9
}
se(eu!=9){
enquanto(al.contains(numMat[i][j])){
j++;
se(j==9){
j=0;i++;
}
}
}
}enquanto(i!=9);
}
public static void initNumMat(Point[][] numMat,ArrayList<Point> al) lança IOException {
for (int i = 0; i < numMat.length; i++) {
for (int j = 0; j < numMat[i].length; j++) {
numMat[i][j] = novo Ponto(i, j, verdadeiro, 0);
}
}
initNumMat2(numMat, al);
}
public static void initNumMat2(Point[][] numMat, ArrayList<Point> al) lança IOException {
BufferedReader br = novo BufferedReader(new InputStreamReader(System.in));
String[] p = nova String[3];
String linha=nulo;
System.out.println("Por favor, insira as informações do ponto de acordo com o formato (i número da linha, j número da coluna e valor v), insira sobre: ijv ");
while((linha = br.readLine())!=null){
if(line.equals("acima"))
quebrar;
p = line.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])]);
}
}
public static void printMat(Ponto[][] numMat) {
System.out.println("--------┬---------┬---------┐");
for (int i = 0; i < numMat.length; i++) {
for (int j = 0; j < numMat[i].length; j++) {
se ((j + 1)% 3 == 0)
System.out.print(numMat[i][j].getValue() + " | ");
outro
System.out.print(numMat[i][j].getValue() + " ");
}
se ((eu + 1)% 3 == 0)
System.out.println("/r/n--------┼---------┼---------┤");
outro
System.out.println();
}
}
}
--- Execute o programa
Insira as informações do ponto de acordo com o formato (número da linha i, número da coluna j e valor v) e insira sobre: ijv ao inserir.
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
sobre
――┬―――┬―――┐
8 1 2 | 7 5 3 |
9 4 3 |
6 7 5 |
――┼―――┼―――┤
1 5 4 |
3 6 9 |
2 8 7 |
――┼―――┼―――┤
5 2 1 |
4 3 8 |
7 9 6 |
――┼―――┼―――┤