代码随想录【Day 28】 | 491.递增子序列 、46.全排列、47.全排列 II

491.递增子序列

题目链接：491.递增子序列

卡尔文解

视频讲解

解题思路及注意事项：

这个递增子序列比较像是取有序的子集。而且本题也要求不能有相同的递增子序列。

这又是子集，又是去重，是不是不由自主的想起了刚刚讲过的90.子集II (opens new window)。

就是因为太像了，更要注意差别所在，要不就掉坑里了！

在90.子集II (opens new window)中我们是通过排序，再加一个标记数组来达到去重的目的。

而本题求自增子序列，是不能对原数组进行排序的，排完序的数组都是自增子序列了。

所以不能使用之前的去重逻辑！

本题给出的示例，还是一个有序数组 [4, 6, 7, 7]，这更容易误导大家按照排序的思路去做了。

为了有鲜明的对比，我用[4, 7, 6, 7]这个数组来举例，抽象为树形结构如图：

代码实现：

class Solution {

private:
    vector<int> path;
    vector<vector<int>> result;

    void back_tracking( vector<int>& nums, int startIdx ){

        if( path.size() > 1 ) 
            result.push_back( path );

        if( startIdx >= nums.size() ) 
            return;

        unordered_set<int> used_set;

        for( int i = startIdx; i < nums.size(); i++ ){

            if( (!path.empty() && nums[ i ] < path.back()) || used_set.find(nums[ i ]) != used_set.end() )
                continue;

            path.push_back( nums[ i ] );
            used_set.insert( nums[ i ] );
            back_tracking( nums, i + 1 );
            path.pop_back();
        }
    }

public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {

        back_tracking( nums, 0 );
        return result;
    }
};

46.全排列

题目链接：46.全排列

卡尔文解

视频讲解

解题思路及注意事项：

此时我们已经学习了77.组合问题 (opens new window)、 131.分割回文串 (opens new window)和78.子集问题 (opens new window)，接下来看一看排列问题。

相信这个排列问题就算是让你用for循环暴力把结果搜索出来，这个暴力也不是很好写。

所以正如我们在关于回溯算法，你该了解这些！ (opens new window)所讲的为什么回溯法是暴力搜索，效率这么低，还要用它？

因为一些问题能暴力搜出来就已经很不错了！

我以[1,2,3]为例，抽象成树形结构如下：

代码实现：

class Solution {

private:
    vector<int> path;
    vector<vector<int>> result;

    void back_tracking( vector<int>& nums, vector<int>& used ){

        if( path.size() == nums.size() ){
            result.push_back( path );
            return;
        }
        
        for( int i = 0; i < nums.size(); i++ ){

            if( used[ i ] == 1 )
                continue;

            path.push_back( nums[ i ] );
            used[ i ] = 1;
            back_tracking( nums, used );
            path.pop_back();
            used[ i ] = 0;
        }

    }

public:
    vector<vector<int>> permute(vector<int>& nums) {

        vector<int> used( nums.size(), 0 );
        back_tracking( nums, used );
        
        return result;

    }
};

47.全排列 II

题目链接：47.全排列II

卡尔文解

视频讲解

解题思路及注意事项：

这道题目和46.全排列 (opens new window)的区别在与给定一个可包含重复数字的序列，要返回所有不重复的全排列。

这里又涉及到去重了。

在40.组合总和II (opens new window)、90.子集II (opens new window)我们分别详细讲解了组合问题和子集问题如何去重。

那么排列问题其实也是一样的套路。

还要强调的是去重一定要对元素进行排序，这样我们才方便通过相邻的节点来判断是否重复使用了。

我以示例中的 [1,1,2]为例 （为了方便举例，已经排序）抽象为一棵树，去重过程如图：

代码实现：

class Solution {

private:
    vector<int> path;
    vector<vector<int>> result;

    void back_tracking( vector<int>& nums, vector<int>& used ){

        if( path.size() == nums.size() ){
            result.push_back( path );
            return;
        }

        for( int i = 0; i < nums.size(); i++ ){
            
            if( i > 0 && nums[ i ] == nums[ i - 1 ] && !used[ i - 1 ] )
                continue;
            
            if( used[ i ] )
                continue;

            path.push_back( nums[ i ] );
            used[ i ] = 1;
            back_tracking( nums, used );
            used[ i ] = 0;
            path.pop_back();
        }
    }

public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {

        sort( nums.begin(), nums.end() );
        vector<int> used( nums.size(), 0 );
        back_tracking( nums, used );
        return result;
    }
};