Java 如何加速我的n*n数独网格生成器？

这是我的数独风格的网格生成器代码。它生成每一个可能不同的n*n网格，其中某一列或行（如数独）中不能有相同的数字，并计算有多少不同的组合。例如，3*3网格的一个示例可以是：

[3,2,1]

[1,3,2]

[2,1,3]

不幸的是，对于任何超过4*4的网格，这需要太长的时间来完成，因此，有谁能帮我稍微编辑一下，以便更快

import java.util.Arrays;

public class GridN {

public static final int SIZE = 3;

public static int count;

public static void main(String[] args) {
    int[][] grid = new int[SIZE][SIZE];
    count = 0;
    bruteSolve(0, 0, grid);
}

public static void bruteSolve(int num1, int num2, int[][] grid) {
    for (int i = 1; i < SIZE + 1; i++) {
        grid[num1][num2] = i;
        if (num2 == SIZE - 1 && num1 == SIZE - 1) {
            if (isValid(grid)) {
                count++;
                System.out.println(Arrays.deepToString(grid));
                System.out.println(count);
            }
        } else if (num2 == SIZE - 1) {
            bruteSolve(num1 + 1, 0, grid);
        } else {
            bruteSolve(num1, num2 + 1, grid);
        }
    }
}

public static boolean isValid(int[][] grid) {
    int factorial = 1;
    int fibonacci = 0;
    int totalX1 = 1;
    int totalY1 = 1;
    int totalX2 = 0;
    int totalY2 = 0;

    for (int i = SIZE; i > 0; i--) {
        factorial = factorial * i;
    }
    for (int i = SIZE; i > 0; i--) {
        fibonacci = fibonacci + i;
    }

    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            totalY1 = totalY1 * grid[i][j]; // checks all columns
            totalX1 = totalX1 * grid[j][i]; // checks all rows
            totalX2 = totalX2 + grid[j][i];
            totalY2 = totalY2 + grid[i][j];
        }
        if (totalX1 != factorial || totalY1 != factorial
                || totalX2 != fibonacci || totalY2 != fibonacci) {
            return false;
        }
        totalX1 = 1;
        totalY1 = 1;
        totalX2 = 0;
        totalY2 = 0;
    }
    return true;
}

}

导入java.util.array；
公共类网格{
公共静态最终整数大小=3；
公共静态整数计数；
公共静态void main（字符串[]args）{
int[][]网格=新的int[SIZE][SIZE]；
计数=0；
bruteSolve（0,0，网格）；
}
公共静态void bruteSolve（int num1、int num2、int[][]网格）{
对于（int i=1；i0；i--）{
阶乘=阶乘*i；
}
对于（int i=SIZE；i>0；i--）{
斐波那契=斐波那契+i；
}
对于（int i=0；i

你说的加速是什么意思？可能的数量随着正方形的大小而大大增加。您可能必须放弃这种蛮力方法，尝试只生成部分但不是所有可能的方块。有关改进现有功能代码的问题，请访问，但请确保以保留的方式提问。换句话说，您正在构建数独生成器，还是在做其他事情，你真的需要所有可能的魔方吗？又是我。根据维基百科的说法，对于大小为6×6或更大的方块，甚至不知道有多少不同的魔法方块。。。