代码随想录day29|491.递增子序列 、46.全排列 、47.全排列 II

491. 非递减子序列

这里有个坑

——根据给出例题中，可以看出，我们是不可以进行排序的，因为一旦排序了， 就会产生多的答案

例如：4767 排完序后就是 4677了，其中有个结果是4677，但是这并不是4767的结果

#include <stdlib.h>  
  
int* path;  
int pathTop;  
int** ans;  
int ansTop;  int* path;
int pathTop;
int** ans;
int ansTop;
int* length;

void copy() {
    int* tempPath = (int*)malloc(sizeof(int) * pathTop);
    memcpy(tempPath, path, pathTop * sizeof(int));
    length[ansTop] = pathTop;
    ans[ansTop++] = tempPath;
}


int find(int* uset, int usetSize, int key) {
    int i;
    for(i = 0; i < usetSize; i++) {
        if(uset[i] == key)
            return 1;
    }
    return 0;
}

void backTracking(int* nums, int numsSize, int startIndex) {
   
    if(pathTop > 1) {
        copy();
    }
    int* uset = (int*)malloc(sizeof(int) * numsSize);
    int usetTop = 0;
    int i;
    for(i = startIndex; i < numsSize; i++) {
        
        if((pathTop > 0 && nums[i] < path[pathTop - 1]) || find(uset, usetTop, nums[i]))
            continue;

        uset[usetTop++] = nums[i];

        path[pathTop++] = nums[i];
        backTracking(nums, numsSize, i + 1);

        pathTop--;
    }
}

int** findSubsequences(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){

    path = (int*)malloc(sizeof(int) * numsSize);
    ans = (int**)malloc(sizeof(int*) * 33000);
    length = (int*)malloc(sizeof(int*) * 33000);
    pathTop = ansTop = 0;

    backTracking(nums, numsSize, 0);

    *returnSize = ansTop;
    *returnColumnSizes = (int*)malloc(sizeof(int) * ansTop);
    int i;
    for(i = 0; i < ansTop; i++) {
        (*returnColumnSizes)[i] = length[i];
    }
    return ans;
}

46. 全排列

和前面的题的区别不大

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume
 * caller calls free().
 */
int* path;
int pathTop;
int** ans;
int ansTop;

void initialize(int* used, int usedLength) {
    int i;
    for (i = 0; i < usedLength; i++) {
        used[i] = 0;
    }
}

void copy() {
    int* tempPath = (int*)malloc(sizeof(int) * pathTop);
    int i;
    for (i = 0; i < pathTop; i++) {
        tempPath[i] = path[i];
    }
    ans[ansTop++] = tempPath;
}
void backTracking(int* nums, int numsSize, int* used) {
 
    if (pathTop == numsSize) {
        copy();
        return;
    }
    int i;
    for (i = 0; i < numsSize; i++) {
       
        if (used[i])
            continue;
        used[i] = 1;
        path[pathTop++] = nums[i];
        backTracking(nums, numsSize, used);
   
        pathTop--;
        used[i] = 0;
    }
}
int** permute(int* nums, int numsSize, int* returnSize,
              int** returnColumnSizes) {
    path = (int*)malloc(sizeof(int) * numsSize);
    ans = (int**)malloc(sizeof(int*) * 1000);
    int* used = (int*)malloc(sizeof(int) * numsSize);

    initialize(used, numsSize);
    ansTop = pathTop = 0;

    backTracking(nums, numsSize, used);

    *returnSize = ansTop;
    *returnColumnSizes = (int*)malloc(sizeof(int) * ansTop);
    int i;
    for (i = 0; i < ansTop; i++) {
        (*returnColumnSizes)[i] = numsSize;
    }
    return ans;
}

47. 全排列 II

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int* path;
int** ans;
int* used;
int pathTop, ansTop;
void copy(){
    int* temp =(int*)malloc(sizeof(int)* pathTop);
    int i;
    for(i = 0;i < pathTop; ++i){
        temp[i] = path[i];
    } 
    ans[ansTop++] = temp;
}
void backTracking(int* used, int *nums, int numsSize){
    if(pathTop == numsSize)
        copy();
    int i;
    for(i = 0; i < numsSize; i++){
        if(used[i] || (i != 0 && nums[i] == nums[i-1] && used[i-1] == 0))
            continue;
        used[i] =1;
        path[pathTop++] = nums[i];
        backTracking(used, nums, numsSize);
        used[i] = 0;
        --pathTop;
    }
}
int cmp(void* a1, void* a2){
    return *(int*)a1 - *(int*)a2;
}
int** permuteUnique(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    qsort(nums, numsSize, sizeof(int), cmp);
    pathTop = ansTop = 0;
    path = (int*)malloc(sizeof(int)*numsSize);
    ans = (int**)malloc(sizeof(int*)*1000);
    used = (int*)malloc(sizeof(int)* numsSize);
    int i;
    for(i = 0; i < numsSize; i++){
        used[i] = 0;
    }
    backTracking(used, nums, numsSize);

    *returnSize = ansTop;
    *returnColumnSizes = (int*)malloc(sizeof(int)*ansTop);
    int z;
    for(z = 0; z < ansTop; z++)
    {
        (*returnColumnSizes)[z] = numsSize;
    } 
    return ans;
}