代码随想录算法训练营第31天 | 491. 非递减子序列 | 46. 全排列 | 47. 全排列 II

491. 非递减子序列

题目链接

解

/**
 * 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 *size = NULL;

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

    return 0;
}

void backtracking(int *nums, int numsSize, int *returnSize, int **ans, int pathidx, int *path, int startidx) {
    if (pathidx >= 2) {
        ans[*returnSize] = (int *)malloc(sizeof(int) * (pathidx+1));
        for (int i = 0; i < pathidx; i++) {
            ans[*returnSize][i] = path[i];
        }
        size[*returnSize] = pathidx;
        (*returnSize)++;
    }

    int *uset = (int *)malloc(sizeof(int) * numsSize);
    int usetidx = 0;

    for (int i = startidx; i < numsSize; i++) {
        if ((pathidx > 0 && nums[i] < path[pathidx-1]) || find(uset, usetidx, nums[i])) continue;

        uset[usetidx++] = nums[i];
        path[pathidx] = nums[i];
        backtracking(nums, numsSize, returnSize, ans, pathidx+1, path, i+1);
    }
}


int** findSubsequences(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    int **ans = (int **)malloc(sizeof(int *) * 40000);
    int *path = (int *)malloc(sizeof(int) * 16);
    memset(path, 0, sizeof(int) * 16);
    size = (int *)malloc(sizeof(int) * 40000);
    memset(size, 0, sizeof(int) * 40000);

    *returnSize = 0;


    backtracking(nums, numsSize, returnSize, ans, 0, path, 0);

    *returnColumnSizes = (int *)malloc(sizeof(int) * *returnSize);
    for (int i = 0; i < *returnSize; i++) {
        (*returnColumnSizes)[i] = size[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 *size;

void backtracking(int *nums, int numsSize, int *returnSize, int **ans, int pathidx, int *path, int *used) {
    if (pathidx == numsSize) {
        ans[*returnSize] = (int *)malloc(sizeof(int) * (pathidx));
        for (int i = 0; i < pathidx; i++) {
            ans[*returnSize][i] = path[i];
        }
        size[*returnSize] = pathidx;
        (*returnSize)++;
    } 

    for (int i = 0; i < numsSize; i++) {
        if (used[i] == true) continue;
        used[i] = true;
        path[pathidx] = nums[i];
        backtracking(nums, numsSize, returnSize, ans, pathidx+1, path, used);
        used[i] = false;
    }
}

int** permute(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    int **ans = (int **)malloc(sizeof(int *) * 40000);
    int *path = (int *)malloc(sizeof(int) * 16);
    int *used = (int *)malloc(sizeof(int) * 16);

    memset(path, 0, sizeof(int) * 16);
    memset(used, 0, sizeof(int) * 16);
    size = (int *)malloc(sizeof(int) * 40000);
    memset(size, 0, sizeof(int) * 40000);

    *returnSize = 0;


    backtracking(nums, numsSize, returnSize, ans, 0, path, used);

    *returnColumnSizes = (int *)malloc(sizeof(int) * *returnSize);
    for (int i = 0; i < *returnSize; i++) {
        (*returnColumnSizes)[i] = size[i];
    }

    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 *size;

void backtracking(int *nums, int numsSize, int *returnSize, int **ans, int pathidx, int *path, int *used) {
    if (pathidx == numsSize) {
        ans[*returnSize] = (int *)malloc(sizeof(int) * (pathidx+1));
        for (int i = 0; i < pathidx; i++) {
            ans[*returnSize][i] = path[i];
        }
        size[*returnSize] = pathidx;
        (*returnSize)++;
        return;
    } 

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

        used[i] = 1;
        path[pathidx] = nums[i];
        backtracking(nums, numsSize, returnSize, ans, pathidx+1, path, used);
        used[i] = 0;
    }
    
}

int cmp(void* elem1, void* elem2) {
    return *((int*)elem1) - *((int*)elem2);
}

int** permuteUnique(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    int **ans = (int **)malloc(sizeof(int *) * 40000);
    int *path = (int *)malloc(sizeof(int) * 16);
    int *used = (int *)malloc(sizeof(int) * 16);

    memset(path, 0, sizeof(int) * 16);
    memset(used, 0, sizeof(int) * 16);
    size = (int *)malloc(sizeof(int) * 40000);
    memset(size, 0, sizeof(int) * 40000);

    *returnSize = 0;

    qsort(nums, numsSize, sizeof(int), cmp);
    backtracking(nums, numsSize, returnSize, ans, 0, path, used);

    *returnColumnSizes = (int *)malloc(sizeof(int) * *returnSize);
    for (int i = 0; i < *returnSize; i++) {
        (*returnColumnSizes)[i] = size[i];
    }

    return ans;
}