leetcode(回溯法):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().
 */


 /*
回溯法框架解题：
result = []
def backtrack(路径, 选择列表):
    if 满足结束条件: (路径长度为numsSize)
        result.add(路径)
        return
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择
*/

int getlineSizes(int n)
{
    int size = 1;
    for (int i = 1; i <= n; i++) {
        size *= i;
    }

    return size;
}

void dfs(int **result , int *returnSize, int **returnColumnSizes, int *nums, int numsSize, int *path, int pos, int *used)
{
    if (pos == numsSize) {
        result[*returnSize] = malloc(sizeof(int) * numsSize);
        memcpy(result[*returnSize], path, sizeof (int) * numsSize);
        //for (int i = 0; i < numsSize; i++) {
        //    printf("%d ", result[*returnSize][i]);
        //}
        //printf("*returnSize = %d\n", *returnSize);
    
        (*returnColumnSizes)[*returnSize] = numsSize;

        (*returnSize)++;
        return;
    }

    for (int i = 0; i < numsSize; i++) {
        if (used[i] != 1) {
            used[i] = 1;
            path[pos] = nums[i];
            dfs(result, returnSize, returnColumnSizes, nums, numsSize, path, pos + 1, used);
            used[i] = 0;
        }
    }

    return;
}

int** permute(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
    *returnSize = 0;

    if (nums == NULL || numsSize <= 0) return NULL;

    int sizes = getlineSizes(numsSize);

    *returnColumnSizes = (int *)malloc(sizeof (int) * sizes);
    int **result = (int **)malloc(sizeof(int *) * (sizes));

    int *path = calloc(numsSize, sizeof (int)); // 每个可能的组合的长度是numsSize
    int *used =  calloc(numsSize, sizeof (int));

    dfs(result, returnSize, returnColumnSizes, nums, numsSize, path, 0, used);

    return result;
}