1．Fibonacci数列递归算法的实现集合全排列问题递归算法的实现整数划分问题递归算法的实现；2．循环赛日程表问题和棋盘覆盖分治算法的实现。

1. Fibonacci数列递归算法的实现:

def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

n = 10
for i in range(n):
    print(fibonacci(i))

2. 集合全排列问题递归算法的实现:

def permute(nums):
    if len(nums) == 0:
        return [[]]
    
    permutations = []
    for i in range(len(nums)):
        remaining = nums[:i] + nums[i+1:]
        for p in permute(remaining):
            permutations.append([nums[i]] + p)
    
    return permutations

nums = [1, 2, 3]
print(permute(nums))

3. 整数划分问题递归算法的实现:

def partition(n, m):
    if n == 0 or m == 1:
        return 1
    elif n < m:
        return partition(n, n)
    elif n >= m:
        return partition(n-m, m) + partition(n, m-1)

n = 5
print(partition(n, n))

4. 循环赛日程表问题的实现:

def schedule(n):
    if n == 1:
        return [[0]]
    
    prev_schedule = schedule(n-1)
    new_schedule = []
    for i in range(len(prev_schedule)):
        new_row = [x + [n-1] for x in prev_schedule[i]]
        new_schedule.append(new_row)
        for j in range(n-1):
            new_row = [x[:j] + [n-1] + x[j:] for x in prev_schedule[i]]
            new_schedule.append(new_row)
    
    return new_schedule

n = 4
schedules = schedule(n)
for s in schedules:
    print(s)

5. 棋盘覆盖分治算法的实现:

def chessboard_cover(board, tr, tc, dr, dc, size, special_r, special_c):
    if size == 1:
        return
    
    tile = 1
    t = tile
    size //= 2
    
    # left top
    if special_r < tr+size and special_c < tc+size:
        chessboard_cover(board, tr, tc, dr, dc, size, special_r, special_c)
    else:
        board[tr+size-1][tc+size-1] = t
        chessboard_cover(board, tr, tc, tr+size-1, tc+size-1, size, special_r, special_c)
    
    # right top
    if special_r < tr+size and special_c >= tc+size:
        chessboard_cover(board, tr, tc+size, dr, dc, size, special_r, special_c)
    else:
        board[tr+size-1][tc+size] = t
        chessboard_cover(board, tr, tc+size, tr+size-1, tc+size, size, special_r, special_c)
    
    # left bottom
    if special_r >= tr+size and special_c < tc+size:
        chessboard_cover(board, tr+size, tc, dr, dc, size, special_r, special_c)
    else:
        board[tr+size][tc+size-1] = t
        chessboard_cover(board, tr+size, tc, tr+size, tc+size-1, size, special_r, special_c)
    
    # right bottom
    if special_r >= tr+size and special_c >= tc+size:
        chessboard_cover(board, tr+size, tc+size, dr, dc, size, special_r, special_c)
    else:
        board[tr+size][tc+size] = t
        chessboard_cover(board, tr+size, tc+size, tr+size, tc+size, size, special_r, special_c)

n = 4
board = [[0] * n for _ in range(n)]
special_r = 1
special_c = 2
chessboard_cover(board, 0, 0, 0, 0, n, special_r, special_c)
for row in board:
    print(row)
``