Java 锦标赛日程递归

Question

我正在为我的 Java 类(class)布置家庭作业，但我一直在思考如何设置递归(必需)以使其正常工作。我们必须提示用户输入“n”个竞争对手(假设它必须是 2 的幂，我们不需要检查有效的用户输入)。每支球队只能与其他球队比赛一次。 n=8 的输出应该是:

1  2  3  4  5  6  7  8
2  1  4  3  6  5  8  7
3  4  1  2  7  8  5  6
4  3  2  1  8  7  6  5
5  6  7  8  1  2  3  4
6  5  8  7  2  1  4  3
7  8  5  6  3  4  1  2
8  7  6  5  4  3  2  1

唯一允许我传递给该方法的参数是“int n”。因此，如果有 16 个团队(即 n=16)，那么第二次调用将传递 8 个，然后传递 4 个，然后传递 2 个，最后传递 1 个。

因此，基于此，我认识到每隔一行只是翻转每对数字。所以对于 2^0，只有一个团队。对于 2^1，它是:

1  2
2  1

对于 2^2，它是 4 个团队，但团队 3 和 4 与团队 1 和 2 具有相同的递归。然后，您交换它们，以便 3 和 4 在 1 和 2 之前出现，然后您再次交换各个对:

1  2  3  4
2  1  4  3
3  4  1  2
4  3  2  1

所以基本上可以将图分成 4 个相等的角，每个对角都相等。

在过去的几天里，我的代码发生了很多变化，但这就是我现在的处境。这实际上是我过去的倒退，但我最初试图传递一个开始行和一个开始列，但我被告知我不应该这样做，而是递归地传递 n。

class MyArray {
    final int MAXROW = 32, MAXCOL = 32;
    int A[][]; //reference variable
    int nR, nC; //number of integers in A, <= MAXSIZE

//constructor
MyArray() {
    A = new int[MAXROW] [MAXCOL];
    nR = nC = 0;
}

void schedule(int n) {
        if (n > 1) {
            schedule(n/2);
            for (int r = 0; r < n/2; r++)
                for (int c = 0; c < n/2; c++) {
                    A[r+n][c] = A[r][c+n];
                    A[r+n][c+n] = A[r][c];
                 }
        }
    }
void printA() {
    printA(nC-1)
}

void printA(int n) {
    if (n >= 0) {
        printA(n-1);
        for (int c = 0; c < nC; c++)
            System.out.printf("%3d", (A[n][c]));
        System.out.println();
    }
}

Answer 1

终于明白了。这是 schedule 方法的代码，简洁明了，基本上，左上角的值 + (n/2) = 右上角和左下角的值。右下角值 = 左上角值。

void schedule(int n) {
    if (n > 0) {
        schedule(n/2);
        if (n == 1)
            A[0][0] = 1;
        else {
            for (int r = 0; r < n/2; r++)
                for (int c = 0; c < n/2; c++) {
                    A[r][c+(n/2)] = A[r][c] + (n/2);
                    A[r+(n/2)][c] = A[r][c] + (n/2);
                    A[r+(n/2)][c+(n/2)] = A[r][c];
                }
        }
    }
}