491.递增子序列 46.全排列 47.全排列 II

491.递增子序列

收结果 时 不能直接return 会缺少 三个数的结果

unordered_set 不是全局变量， 是每层树 的 变量 ， 所以不用 回溯 ， 每层都是新的

class Solution {
public:
vector < int > path;
vector < vector < int > > result;
void backtracking ( vector < int > nums , int startindex ) {
    if ( path.size() > 1 ) {
        result.push_back( path ) ;
        //return ;     //这里不能return 会缺少 三个的结果
    }
    unordered_set < int > set;
    for ( int i = startindex ; i < nums.size() ; i++ ) {
        if ( !path.empty() && nums[i] < path.back() || set.find(nums[i]) != set.end() )continue;
        path.push_back( nums[i] );
        set.insert( nums[i] );
        backtracking( nums , i + 1 ) ;
        path.pop_back();
        
    }
}
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking( nums , 0 );
        return result;
    }
};

46.全排列

排列 不能 用 startindex 因为 startindex 取得是 它之后的 元素 ， 排列是 所有元素都要 有

用 used 记录 取过的元素  如果 取过 就跳过

class Solution {
public:
vector < int > path;
vector < vector < int > > result;

void backtracking ( vector < int > nums , vector < bool > used ) {
    if ( path.size() == nums.size() ) {
        result.push_back( path );
        return;
    }
    for ( int i = 0 ; i < nums.size() ; i++ ) {
        if ( used[i] == true ) continue;
        used[i] = true;
        path.push_back( nums[i] );
        backtracking( nums , used ) ;
        used[i] = false;
        path.pop_back();
    }
}
    vector<vector<int>> permute(vector<int>& nums) {
        vector < bool > used( nums.size() , false );
        backtracking( nums , used );
        return result;
    }
};

47.全排列 II

去重 前 一定 要 排序 ， 将相同的数 放到一起

去重和之前一样 用used 

class Solution {
public:
vector < int > path;
vector < vector < int > > result;
void backtracking ( vector < int > nums , vector < bool > 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] == false ) continue;
        if ( used[i] == true ) continue;
        used[i] = true;
        path.push_back( nums[i] );
        backtracking( nums , used );
        used[i] = false;
        path.pop_back();
    }
}
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort( nums.begin() , nums.end() );
        vector < bool > used( nums.size() , false );
        backtracking( nums , used );
        return result;
    }
};