设有n个选手进行循环比赛，其中n = 2^m，要求每名选手要与其他n - 1名选手都赛一次，每名选手每天比赛一次，循环赛共进行n - 1天，要求每天没有选手轮空。

这是一个经典的问题，可以采用递归的思路解决。

首先将n个选手分为两组，每组n/2个选手，分别记为A组和B组。对于第i天比赛，A组中第j个选手与B组中第(i+j) mod (n/2)个选手进行比赛。比如，对于n=8，第3天比赛的对阵情况如下图所示：

A组              B组
1                5
2                6
3                7
4                8

可以看出，每个选手都恰好与其他n-1个选手进行了比赛，且每天都没有选手轮空。

接下来，递归地处理A组和B组，直到只剩下一个选手为止。假设A组中的选手已经排好了赛程，B组中的选手也已经排好了赛程，那么如何将A组和B组的赛程合并呢？

假设A组中第i个选手的赛程为(A_i,1), (A_i,2), ..., (A_i,n/2)，B组中第i个选手的赛程为(B_i,1), (B_i,2), ..., (B_i,n/2)，则将A组和B组的赛程合并的方法如下：

- 对于第i个选手，其赛程为(A_i,1), (B_i,1), (A_i,2), (B_i,2), ..., (A_i,n/2), (B_i,n/2)。
- 对于第j个选手，其赛程为(A_j,1), (B_j,2), (A_j,2), (B_j,3), ..., (A_j,n/2), (B_j,1))。

可以看出，每个选手都恰好与其他n-1个选手进行了比赛，且每天都没有选手轮空。同时，这种赛程的构造方法具有递归性质，因此可以通过递归的方式求解任意n的情况。

下面是Python代码实现：

def tournament_schedule(n):
    if n == 1:
        return [[1]]
    else:
        # 递归处理A组和B组
        A = tournament_schedule(n//2)
        B = tournament_schedule(n//2)
        # 合并赛程
        schedule = []
        for i in range(n//2):
            row = []
            for j in range(n//2):
                row.append(A[i][j])
                row.append(B[i][j] + n//2)
            schedule.append(row)
        for i in range(n//2, n):
            row = []
            for j in range(n//2):
                row.append(A[j][i-n//2] + n//2)
                row.append(B[j][i-n//2])
            schedule.append(row)
        return schedule

调用tournament_schedule(n)函数即可得到n个选手的赛程，其中n必须是2的整数次幂。