代码随想录算法训练营第二十九天|491. 递增子序列、46. 全排列、47. 全排列 II

491. 递增子序列

题目描述：

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

 我的想法：对原数组进行排序后进行数层剪枝，但是这样操作会扩大结果集，将原本不属于结果集的子序列包括进去，如下面例子：

输入：nums = [4,7,6,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

正确输出：[[4,6],[4,6,7],[4,7],[4,7,7],[6,7],[7,7]]

 思路是对的，需要进行数层去重，但是不能对原数组进行排序。那就在单层操作的时候判断已经选取的元素是否有重复的。用Inpath()函数做判断。

int** ret;
int ret_num;
int* path;
int path_num;
int *len;

bool Inpath(int* uset,int uset_num,int target){
    for(int i=0;i<uset_num;i++){
        if(uset[i]==target)     return true;
    }
    return false;
}
void backtracking(int* nums,int numsSize,int startIndex){
    //收获结果
    if(path_num>=2){
        int* temp=(int*)malloc(sizeof(int)*path_num);
        for(int i=0;i<path_num;i++){
            temp[i]=path[i];
        }
        len[ret_num]=path_num;
        ret[ret_num++]=temp;
    }
    //终止条件
    if(startIndex>=numsSize)    return ;
    //path随着递归不断改变，uset数组用来记录当前选用了哪些元素
    int* uset=(int*)malloc(sizeof(int)*numsSize);
    int uset_num=0;
    for(int i=startIndex;i<numsSize;i++){
        //数层剪枝
        if(Inpath(uset,uset_num,nums[i]))    continue;
        //非递增的元素跳过
        if(path_num==0||path_num>0&&nums[i]>=path[path_num-1]){
            uset[uset_num++]=nums[i];
            path[path_num++]=nums[i];
            backtracking(nums,numsSize,i+1);
            path_num--;
        }     
    }
}

int** findSubsequences(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
    ret=(int**)malloc(sizeof(int*)*33000);
    path=(int*)malloc(sizeof(int)*numsSize);
    len=(int**)malloc(sizeof(int*)*33000);
    ret_num=path_num=0;
    backtracking(nums,numsSize,0);
    *returnSize=ret_num;
    *returnColumnSizes=(int*)malloc(sizeof(int)*ret_num);
    for(int i=0;i<ret_num;i++){
        (*returnColumnSizes)[i]=len[i];
    }
    return ret;
}

46. 全排列

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

两种方法：

1. 像上一个题目一样设置一个临时数组存放path中的结果，每次循环判断当前元素是否出现在元素中。
2. 设置一个数组sign存放原数组总个元素的使用情况，每次判断sign[i]的状态（0或者1）。

使用第二种方法更为高效（因为上一道道题目没有规定了每个元素都不相同，只记录元素下标的状态不能完全去重）：

int** ret;
int ret_num;
int* path;
int path_num;

void backtracking(int* nums,int numsSize,int* sign){
    //收割结果
    if(path_num==numsSize){
        int* temp=(int*)malloc(sizeof(int)*path_num);
        for(int i=0;i<path_num;i++){
            temp[i]=path[i];
        }
        ret[ret_num++]=temp;
        return ;
    }
    for(int i=0;i<numsSize;i++){
        if(sign[i]==1)    continue;
        sign[i]=1;
        path[path_num++]=nums[i];
        backtracking(nums,numsSize,sign);
        sign[i]=0;
        path_num--;
        
    }
}

int** permute(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
    ret=(int**)malloc(sizeof(int*)*33000);
    path=(int*)malloc(sizeof(int)*numsSize);
    ret_num=path_num=0;
    //sign记录元素是否在结果集中
    int* sign=(int*)malloc(sizeof(int)*numsSize);
    memset(sign,0,numsSize);
    backtracking(nums,numsSize,sign);
    *returnSize=ret_num;
    *returnColumnSizes=(int*)malloc(sizeof(int)*ret_num);
    for(int i=0;i<ret_num;i++){
        (*returnColumnSizes)[i]=numsSize;
    }
    return ret;
}

47. 全排列 II

题目描述：给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

跟着代码随想录一道题一道题做下来，还是比较好想的。

在46. 全排列的基础上没有了原数组中元素各不相同的条件，很容易想到对原数组进行排序之后进行数层去重，剩下操作和全排列的题目一致。

int** ret;
int ret_num;
int* path;
int path_num;

int cmp_int(const void* e1, const void* e2){
	return *(int*)e1 - *(int*)e2;
}

void backtracking(int* nums,int numsSize,int* sign){
    //收割结果
    if(path_num==numsSize){
        int* temp=(int*)malloc(sizeof(int)*path_num);
        for(int i=0;i<path_num;i++){
            temp[i]=path[i];
        }
        ret[ret_num++]=temp;
        return ;
    }
    for(int i=0;i<numsSize;i++){
        //数层去重
        if((i>0&&nums[i]==nums[i-1]&&sign[i-1]==0))    continue;
        //跳过当前元素
        if(sign[i]==1)      continue;
        sign[i]=1;
        path[path_num++]=nums[i];
        backtracking(nums,numsSize,sign);
        sign[i]=0;
        path_num--;
        
    }
}

int** permuteUnique(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
    ret=(int**)malloc(sizeof(int*)*33000);
    path=(int*)malloc(sizeof(int)*numsSize);
    ret_num=path_num=0;
    qsort(nums,numsSize,sizeof(int),cmp_int);
    //sign记录元素是否在结果集中
    int* sign=(int*)malloc(sizeof(int)*numsSize);
    memset(sign,0,numsSize);
    backtracking(nums,numsSize,sign);
    *returnSize=ret_num;
    *returnColumnSizes=(int*)malloc(sizeof(int)*ret_num);
    for(int i=0;i<ret_num;i++){
        (*returnColumnSizes)[i]=numsSize;
    }
    return ret;
}