分治策略求解循环赛日程表，用Java实现

分治策略求解循环赛日程表的思路如下：

1. 如果有n个参赛选手，则需要n-1轮比赛才能决出胜负。

2. 将n个参赛选手分成两组，分别为左组和右组，每组有n/2个选手。

3. 第一轮比赛，左组的第i个选手与右组的第i个选手比赛，共进行n/2场比赛。

4. 第二轮比赛，左组的第i个选手与右组的第n/2+i个选手比赛，共进行n/2场比赛。

5. 第三轮比赛，左组的第i个选手与右组的第2n/2+i个选手比赛，共进行n/2场比赛。

6. 重复上述步骤，直到进行了n-1轮比赛。

7. 如果n为奇数，需要将其中一名选手放入“轮空”，即不进行比赛的队列中。

8. 对于任意一名选手，他在每一轮比赛中都只会出现一次。

9. 每场比赛的胜者在下一轮比赛中始终在左侧，而败者则始终在右侧。

下面是Java代码实现：

public class RoundRobin {
    public static void main(String[] args) {
        int n = 6; // 参赛选手数
        int[][] schedule = new int[n][n]; // 日程表

        // 初始化参赛选手
        int[] players = new int[n];
        for (int i = 0; i < n; i++) {
            players[i] = i + 1;
        }

        // 计算日程表
        schedule = roundRobin(players, 0, n - 1);

        // 输出日程表
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print(schedule[i][j] + " ");
            }
            System.out.println();
        }
    }

    // 分治策略求解循环赛日程表
    public static int[][] roundRobin(int[] players, int start, int end) {
        int n = end - start + 1;
        int[][] schedule = new int[n][n];

        // 递归终止条件
        if (n == 1) {
            return schedule;
        }

        // 分组
        int[] left = new int[n / 2];
        int[] right = new int[n / 2];
        for (int i = 0; i < n / 2; i++) {
            left[i] = players[start + i];
            right[i] = players[start + n / 2 + i];
        }

        // 递归计算左右组的日程表
        int[][] leftSchedule = roundRobin(left, 0, n / 2 - 1);
        int[][] rightSchedule = roundRobin(right, 0, n / 2 - 1);

        // 计算日程表
        for (int i = 0; i < n / 2; i++) {
            for (int j = 0; j < n / 2; j++) {
                // 左组的第i个选手与右组的第i+j个选手比赛
                schedule[i][j] = left[i];
                schedule[j][i] = right[i + j];
            }
        }

        // 处理“轮空”的选手
        if (n % 2 == 1) {
            int k = players[end];
            for (int i = 0; i < n / 2; i++) {
                schedule[i][n / 2] = k;
                schedule[n / 2][i] = k;
            }
        }

        // 合并日程表
        for (int i = 0; i < n / 2; i++) {
            for (int j = 0; j < n / 2; j++) {
                schedule[i + n / 2][j + n / 2] = leftSchedule[i][j];
                schedule[i][j + n / 2] = rightSchedule[i][j];
                schedule[i + n / 2][j] = rightSchedule[j][i];
                schedule[i][j] = leftSchedule[i][j];
            }
        }

        return schedule;
    }
}