【C++】每日一题 46 全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

可以使用回溯算法来解决。回溯算法通过尝试所有可能的选择来得到问题的解
为了给排列的元素去重有两种解法
解法一：

#include <vector>

void backtrack(std::vector<int>& nums, std::vector<bool>& used, std::vector<int>& permutation, std::vector<std::vector<int>>& result) {
    if (permutation.size() == nums.size()) {
        result.push_back(permutation);
        return;
    }
    
    for (int i = 0; i < nums.size(); ++i) {
        if (!used[i]) {
            used[i] = true;
            permutation.push_back(nums[i]);
            backtrack(nums, used, permutation, result);
            permutation.pop_back();
            used[i] = false;
        }
    }
}

std::vector<std::vector<int>> permute(std::vector<int>& nums) {
    std::vector<std::vector<int>> result;
    std::vector<int> permutation;
    std::vector<bool> used(nums.size(), false);
    backtrack(nums, used, permutation, result);
    return result;
}

时间复杂度分析：

在回溯算法中，我们尝试了每个数字作为当前位置的可能性，所以总共有 N! 种排列（其中 N 是数组的长度）。
每种排列的生成过程中，需要 O(N) 的时间来将数字加入或移出排列中。
因此，总的时间复杂度为 O(N * N!)，其中 N 为数组的长度。

空间复杂度分析：

递归调用过程中，需要额外的空间来存储当前的排列以及记录数字是否被使用的情况。这些额外的空间在最坏情况下需要 O(N) 的空间。
此外，存储结果的容器需要 O(N!) 的空间来存储所有可能的排列。
因此，总的空间复杂度为 O(N + N!)，其中 N 为数组的长度。
综合来看，全排列算法的时间复杂度是阶乘级别的，空间复杂度也与排列的数量成正比。

解法二：

#include <vector>

void backtrack(std::vector<int>& nums, int start, std::vector<std::vector<int>>& result) {
    if (start == nums.size()) {
        result.push_back(nums);
        return;
    }
    
    for (int i = start; i < nums.size(); ++i) {
        if (i != start && nums[i] == nums[start]) {
            continue; // Skip duplicate elements
        }
        
        std::swap(nums[start], nums[i]);
        backtrack(nums, start + 1, result);
        std::swap(nums[start], nums[i]); // Backtrack
    }
}

std::vector<std::vector<int>> permuteUnique(std::vector<int>& nums) {
    std::sort(nums.begin(), nums.end()); // Sort the input array to handle duplicates
    std::vector<std::vector<int>> result;
    backtrack(nums, 0, result);
    return result;
}

这里使用了 std::swap 函数来交换数组中的元素来避免重复排列。在回溯过程中检查当前位置之后是否有重复元素，若有则跳过。这样可以保证在得到的结果中不会有重复的排列。

时间复杂度分析：

在回溯算法中，我们仍然尝试了每个数字作为当前位置的可能性，但通过交换元素的方式可以避免生成重复的排列。因此，总共有 N! 种排列（其中 N 是数组的长度）。
每种排列的生成过程中，需要 O(N) 的时间来进行交换操作。
因此，总的时间复杂度为 O(N * N!)，其中 N 为数组的长度。

空间复杂度分析：

递归调用过程中，不需要额外的空间来存储记录数字是否被使用的情况，因为我们通过交换元素的方式来避免重复排列。
存储结果的容器仍然需要 O(N!) 的空间来存储所有可能的排列。
因此，总的空间复杂度为 O(N!)，其中 N 为数组的长度。
综合来看，修改后的全排列算法的时间复杂度仍然是阶乘级别的，但相比使用额外的标志数组，空间复杂度得到了一定的优化。