全排列问题

1.输入不含重复元素的整数数组，返回所有的可能排列。

重复选择剪枝即每轮选择不同的元素

重复选择剪枝（不引入额外列表）

def permutations(nums):
    state = []
    res = []
    backtrack(state, nums, res)
    return res


def backtrack(state, choices, res):
    # 判断是否为解
    if len(state) == len(choices):
        # 若为解，记录解
        res.append(list(state))
        # 记录后，结束本轮
        return
    # 不为解，遍历所有可能的选择
    for choice in choices:
        # 剪枝，对遍历的选择进行剪枝，减少运行步骤
        if choice not in state:
            # 尝试，更新state和selected的状态
            state.append(choice)
            # 递归，判断尝试是否为解，并进行下一轮选择
            backtrack(state, choices, res)
            # 回退，撤销选择，恢复到之前的状态
            state.pop()


if __name__ == '__main__':
    nums = [1, 2, 3]
    print(permutations(nums))

重复选择剪枝（引入额外列表selected)

def permutations(nums):
    state = []
    res = []
    selected = [False] * len(nums)
    backtrack(state, nums, res, selected)
    return res


def backtrack(state, choices, res, selected):
    # 判断是否为解
    if len(state) == len(choices):
        # 若为解，记录解
        res.append(list(state))
        # 记录后结束本轮
        return
    # 不为解，遍历所有可能的选择
    for i, choice in enumerate(choices):
        # 对遍历的选择进行剪枝，减少运行步骤
        if choice not in state:
            # 尝试,更新state和selected的状态
            state.append(choice)
            selected[i] = True
            # 递归，判断尝试是否为解，并进行下一次选择
            backtrack(state, choices, res, selected)
            # 回退：取消选择，回复到之前的状态
            state.pop()
            selected[i] = False


if __name__ == '__main__':
    nums = [1, 2, 3]
    print(permutations(nums))

2.输入包含重复元素的整形数组，返回所有排列可能

第一次尝试：

def permutations(nums: list):
    # 描述问题状态
    state = []
    # 存储所有选择
    choices: list = nums
    # 存储符合条件的结果
    res = []
    # 创建selected列表记录元素是否被选择，保证元素不会被重复选择。
    selected = [False] * len(nums)
    # 在每轮选择中创建集合duplicated记录已经选择的元素，保证相同元素在同一轮中只选择一次。
    duplicated = set()
    # 回溯
    backtrack(state, choices, selected, duplicated, res)
    return res


def backtrack(state, choices, selected, duplicated, res):
    # 判断是否为解
    if len(state) == len(choices):
        # 若符合，将结果记录
        res.append(list(state))
        # 添加后，结束本轮选择
        return
    # 不为解，遍历所有选择
    for i, choice in enumerate(choices):
        # 对选择进行剪枝，减少运行步骤
        # 1.重复选择剪枝，保证每轮选择的元素不重复
        # 2.相同元素剪枝，保证相同的元素在每轮选择中只选择一次
        if not selected[i] and choice not in duplicated:
            # 尝试，更新状态
            state.append(choice)
            selected[i] = True
            duplicated.add(choice)
            # 回溯，判断选择是否未解，是否进行下一轮选择
            backtrack(state, choices, selected, duplicated, res)
            # 回退，撤销选择，恢复状态
            state.pop()
            selected[i] = False
            duplicated.pop()


if __name__ == '__main__':
    nums = [1, 1, 4]
    print(permutations(nums))

错误：

1.集合duplicated创建在错误的位置。此时[1,1,4]在进行第二轮选择时无法选择1,比不在同一轮选择中选择相同元素的要求更加严苛，造成函数找不到解的情况

2.集合pop()为随机弹出一个元素，而不是尾部弹出

第二次尝试：

def permutations(nums: list):
    # 描述问题状态
    state = []
    # 存储所有选择
    choices: list = nums
    # 存储符合条件的结果
    res = []
    # 创建selected列表记录元素是否被选择，保证元素不会被重复选择。
    selected = [False] * len(nums)
    # 回溯
    backtrack(state, choices, selected, res)
    return res


def backtrack(state, choices, selected, res):
    # 判断是否为解
    if len(state) == len(choices):
        # 若符合，将结果记录
        res.append(list(state))
        # 添加后，结束本轮选择
        return
    # 在每轮选择中创建集合duplicated记录已经选择的元素，保证相同元素在同一轮中只选择一次。
    duplicated = set()
    # 不为解，遍历所有选择
    for i, choice in enumerate(choices):
        # 对选择进行剪枝，减少运行步骤
        # 1.重复选择剪枝，保证每轮选择的元素不重复
        # 2.相同元素剪枝，保证相同的元素在每轮选择中只选择一次
        if not selected[i] and choice not in duplicated:
            # 尝试，更新状态
            state.append(choice)
            selected[i] = True
            duplicated.add(choice)
            # 回溯，判断选择是否未解，是否进行下一轮选择
            backtrack(state, choices, selected, res)
            # 回退，撤销选择，恢复状态
            state.pop()
            selected[i] = False


if __name__ == '__main__':
    nums = [1, 1, 4]
    print(permutations(nums))