Question

我正在尝试编写一个程序，可以为固定的N维生成所有可能的魔方。我通过用值填充对角线单元格然后用值填充行来实现它。

当我在行中填充时似乎陷入无限循环，但似乎无法弄清楚如何或为什么。我没有实现总和检查，以检查行或列的总和是否正确，但这是无关紧要的。

如果有人能帮助我，我会非常感激。代码吼叫

public class Magic {

public static final int DIMENSION = 3;
public static final int DIMSQ = DIMENSION * DIMENSION;
public static int[][] array = new int[DIMENSION][DIMENSION];
public static boolean[] boolArray = new boolean[DIMENSION * DIMENSION];
public static final int sum = (DIMENSION * (DIMENSION * DIMENSION + 1)) / 2;

/*
 * Inicializaljuk a matrixunkat, illetve a boolean matrixunkat
 * Initializes the matrix and boolArray with values.
 */
public static void init() {
    for (int e[] : array) {
        for (int e2 : e) {
            e2 = 0;
        }
    }
    for (boolean e : boolArray) {
        e = false;
    }
}

/*
 * Ki irassa a matrix jelenlegi allapotat konzolra
 * Prints the array out to the console.
 */
public static void print() {
    for (int i[] : array) {
        for (int j : i) {
            System.out.print(j + ",");
        }
        System.out.println();
    }
    System.out.println();
}

/*
 * feltolti a foatlot adatokkal, majd meghivja a diagonal2-t
 * fills diagonal cells with values
 */
public static void diagonal1(int x) {

    for (int i = 0; i < DIMSQ; i++) {
        if (!boolArray[i]) {
            boolArray[i] = true;
            array[x][x] = i + 1;
            if (x < DIMENSION - 1) {
                diagonal1(x + 1);
            } else
                diagonal2(0);
            boolArray[i] = false;
        }
    }

}

/*
 * feltolti a mellekatlot adatokkal, majd meghivja a row(0,0,0)-t
 * fills diagonal cells with values
 */
public static void diagonal2(int x) {

    for (int i = 0; i < DIMSQ; i++) {
        if (!boolArray[i]) {

            if (array[DIMENSION - 1 - x][x] == 0) {
                boolArray[i] = true;
                array[DIMENSION - 1 - x][x] = i + 1;
            }
            if (x < DIMENSION - 1) {
                diagonal2(x + 1);
            } else
                row(0, 0);
            boolArray[i] = false;
        }
    }
}
/*
 * feltolti a sorokat adatokkal
 * fills rows with values
 */
public static void row(int x, int y) {
    for (int i = 0; i < DIMSQ; i++) {
        if (!boolArray[i]) {

            if (array[x][y] == 0) {
                boolArray[i] = true;
                array[x][y] = i;
            }

            if (x < DIMENSION - 1) {
                row(x + 1, y);
            } else if(y < DIMENSION - 1) { 
                row(0,y+1);
            } else print();

            boolArray[i] = false;

        }
    }
}

public static void main(String[] args) {
    // TODO Auto-generated method stub
    init();
    print();
    diagonal1(0);

}

}

Answer 1

我怀疑是row()方法（请参阅下面的评论）：

public static void row(int x, int y) {
    for (int i = 0; i < DIMSQ; i++) {
        if (!boolArray[i]) {

            if (array[x][y] == 0) {
                boolArray[i] = true; // <-- this one
                array[x][y] = i;
            }

            if (x < DIMENSION - 1) {
                row(x + 1, y);
            } else if(y < DIMENSION - 1) { 
                row(0,y+1);
            } else print();

            boolArray[i] = false; // <-- would be OVERWRITTEN by this one

        }
    }
}

Answer 2

我不认为这是无限的，但很长：

diag1中的9步循环，
diag1的3 - 深度退缩，
然后diag2中的9步循环 diag2中的3深递归，
然后row中的9步循环 row中的~6深度递归。

即使并非所有循环都在每次迭代中执行复杂的操作，如果您还考虑到在方块的每个“分辨率”处打印正方形的状态，这可以轻松地添加多个小时 - 打印到控制台需要时间。

Magic Square递归无限循环java

2 个答案: