打印n个0和m个1，以便没有两个0和三个不在一起

这是一道经典的题目，目的是打印出长度为n+m的01字符串，满足以下两个条件：

1. 0的个数为n，1的个数为m。
2. 不能出现两个0相邻，也不能出现连续的三个1。

解法一

我们可以通过递归实现。假设prefix表示已经处理的前缀，num_zeros表示还需输出的0的个数，num_ones表示还需输出的1的个数。则递归公式为：

if num_zeros == 0 and num_ones == 0:
    print(prefix)
    return

if num_zeros > 0:
    dfs(prefix + '0', num_zeros - 1, num_ones)

if num_ones > 0 and prefix[-2:] != '11':
    dfs(prefix + '1', num_zeros, num_ones - 1)

具体地，如果当前已经处理的前缀长度等于k，则输出该前缀。否则，如果需要输出的0的个数不为0，则可以继续加入一个0，递归处理后面的0和1；如果需要输出的1的个数不为0，且前缀中最后两个字符不是11，则可以继续加入一个1，递归处理后面的0和1。

这种做法的时间复杂度为O(2^(n+m))，空间复杂度为O(n+m)。由于存在大量的重叠子问题，可以加上记忆化搜索，将时间复杂度降为O(nm)。

解法二

我们也可以用动态规划实现。设dp[i][j][0/1]表示当前已经处理了前i个字符，其中0的个数为j，最后一个字符为0/1的方案数。递推公式为：

for i in range(1, n + m + 1):
    for j in range(min(i, n) + 1):
        if j == 0:
            dp[i][j][1] = dp[i - 1][j][0]
        elif i - j >= 3:
            dp[i][j][1] = dp[i - 1][j][0] + dp[i - 1][j - 1][1]
        else:
            dp[i][j][1] = dp[i - 1][j][0]
        if i - j >= 2 and i >= 3:
            dp[i][j][0] = dp[i - 1][j][1] + dp[i - 1][j][0]

具体地，如果要输出一个0，则可以从dp[i-1][j][0]和dp[i-1][j][1]转移过来；如果要输出一个1，则可以从dp[i-1][j-1][1]和dp[i-1][j][0]转移过来。需要注意的是，在输出1的时候，需要保证前缀中不能出现两个连续的1，因此需要判断i-j是否大于等于3。

这种做法的时间复杂度为O(nm)，空间复杂度为O(nm)。

代码实现

下面是使用Python语言实现的代码。

递归实现

def print_01_strings_dfs(n: int, m: int):
    memo = {}

    def dfs(prefix, num_zeros, num_ones):
        if (prefix, num_zeros, num_ones) in memo:
            return

        memo[(prefix, num_zeros, num_ones)] = True

        if num_zeros == 0 and num_ones == 0:
            print(prefix)
            return

        if num_zeros > 0:
            dfs(prefix + '0', num_zeros - 1, num_ones)

        if num_ones > 0 and prefix[-2:] != '11':
            dfs(prefix + '1', num_zeros, num_ones - 1)

    dfs('', n, m)

动态规划实现

def print_01_strings_dp(n: int, m: int):
    dp = [[[0] * 2 for _ in range(n + 1)] for _ in range(n + m + 1)]

    dp[0][0][0] = 1

    for i in range(1, n + m + 1):
        for j in range(min(i, n) + 1):
            if j == 0:
                dp[i][j][1] = dp[i - 1][j][0]
            elif i - j >= 3:
                dp[i][j][1] = dp[i - 1][j][0] + dp[i - 1][j - 1][1]
            else:
                dp[i][j][1] = dp[i - 1][j][0]
            if i - j >= 2 and i >= 3:
                dp[i][j][0] = dp[i - 1][j][1] + dp[i - 1][j][0]

    for i in range(n + m + 1):
        print(dp[i][n][0] + dp[i][n][1])

总结

本题是一道比较有趣的组合问题，涉及到了递归和动态规划两种不同的解法，它们的时间复杂度和空间复杂度都有所不同。需要特别注意的是，在实现过程中，需要仔细考虑边界条件，并进行优化，否则可能会超时或者出现错误的答案。