数据结构算法题——图

leetcode-39.组合总数（dfs）

leetcode-39.组合总数（dfs）
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

int ansSize;
int combineSize;
int* ansColumnSize;

void dfs(int* candidates, int candidatesSize, int target, int** ans, int* combine, int idx)
{
    if(target < 0)
        return;
    if(target == 0){
        int* tmp = malloc(sizeof(int) * combineSize);
        for(int i = 0; i < combineSize; i++){
            tmp[i] = combine[i];
        }
        ans[ansSize] = tmp;
        ansColumnSize[ansSize++] = combineSize;
    }
    for(int i = idx; i < candidatesSize; i++){
        combine[combineSize++] = candidates[i];
        dfs(candidates, candidatesSize, target-candidates[i], ans, combine, i);
        combine[combineSize--] = 0;
    }
}

int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes){
    ansSize = combineSize = 0;
    int** ans = malloc(sizeof(int*) * 1001);
    ansColumnSize = malloc(sizeof(int) * 1001);
    int combine[2001];
    dfs(candidates, candidatesSize, target, ans, combine, 0);
    *returnSize = ansSize;
    *returnColumnSizes = ansColumnSize;
    return ans;
}

时间复杂度：O(S)，其中 S 为所有可行解的长度之和。从分析给出的搜索树我们可以看出时间复杂度取决于搜索树所有叶子节点的深度之和，即所有可行解的长度之和。
空间复杂度：O(target)。除答案数组外，空间复杂度取决于递归的栈深度，在最差情况下需要递归 O(target) 层。

leetcode-40.组合总数 II（快速排序＋dfs）

leetcode-40.组合总数 II（快速排序＋dfs）
给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

注意：解集不能包含重复的组合。

void quickSort(int* candidates, int first, int end)
{
    int tmp, l, r;
    if(first >= end)
        return;
    tmp = candidates[first];
    l = first, r = end;
    while(l < r){
        while(l < r && tmp <= candidates[r])
            r--;
        if(l < r)
            candidates[l] = candidates[r];
        while(l < r && candidates[l] <= tmp)
            l++;
        if(l < r)
            candidates[r] = candidates[l];
    }
    candidates[l] = tmp;
    quickSort(candidates, first, l-1);
    quickSort(candidates, l+1, end);
}

void dfs(int* candidates, int candidatesSize, int target, int** ans, int* combine, int idx, int combineSize, int* returnSize, int** returnColumnSizes)
{
    if(target < 0)
        return;
    if(target == 0){
        ans[*returnSize] = (int*)malloc(sizeof(int) * combineSize);
        for(int i = 0; i < combineSize; i++){
            ans[(*returnSize)][i] = combine[i];
        }
        (*returnColumnSizes)[*returnSize] = combineSize;
        (*returnSize)++;
        return;
    }
    int i = idx;
    while(i < candidatesSize){
        combine[combineSize] = candidates[i];

        dfs(candidates, candidatesSize, target-candidates[i], ans, combine, i+1, combineSize+1,returnSize, returnColumnSizes);
        while(i < candidatesSize - 1 && candidates[i] == candidates[i+1]) i++;
        i++;
        // combine[combineSize--] = 0;
    }
}

int** combinationSum2(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes){
    *returnSize = 0;
    if(candidatesSize == 0)
        return 0;
    quickSort(candidates, 0, candidatesSize - 1);
    int** ans = (int**)malloc(sizeof(int) * 1000001);
    *returnColumnSizes = (int*)malloc(sizeof(int) * 1000001);
    int combine[target];
    dfs(candidates, candidatesSize, target, ans, combine, 0, 0, returnSize, returnColumnSizes);
    return ans;
}

这题写了好久啊，还是有点问题，先放着吧。（代码参考了别人的，可以AC）

leetcode-78.子集

leetcode-78.子集
给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

int** ans;
int* ansColSize;
int ansSize;
int* t;
int tSize;

void dfs(int cur, int* nums, int numsSize)
{
    if(cur == numsSize){
        int* tmp = malloc(sizeof(int) * tSize);
        memcpy(tmp, t, sizeof(int) * tSize);
        ansColSize[ansSize] = tSize;
        ans[ansSize++] = tmp;
        return ;
    }
    t[tSize++] = nums[cur];
    dfs(cur + 1, nums, numsSize);
    tSize--;
    dfs(cur + 1, nums, numsSize);
}

int** subsets(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
    ans = malloc(sizeof(int*) * (1 << numsSize));
    ansColSize = malloc(sizeof(int) * (1 << numsSize));
    t = malloc(sizeof(int) * numsSize);
    *returnSize = 1 << numsSize;
    ansSize = tSize = 0;
    dfs(0, nums, numsSize);
    *returnColumnSizes = ansColSize;
    return ans;
}

时间复杂度：O(n × 2ⁿ)。一共2ⁿ个状态，每种状态需要 O(n) 的时间来构造子集。
空间复杂度：O(n)。临时数组 t 的空间代价是 O(n)，递归时栈空间的代价为 O(n)。

leetcode-207.课程表（拓扑排序）

leetcode-207.课程表（拓扑排序）
你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

bool canFinish(int numCourses, int** prerequisites, int prerequisitesSize, int* prerequisitesColSize){
    int** edges = (int**)malloc(sizeof(int*) * numCourses);
    for(int i = 0; i < numCourses; i++){
        edges[i] = (int*)malloc(0);
    }
    int edgeColSize[numCourses];
    memset(edgeColSize, 0, sizeof(edgeColSize));
    int indeg[numCourses];
    memset(indeg, 0, sizeof(indeg));
    for(int i = 0; i < prerequisitesSize; i++){
        int a = prerequisites[i][1], b = prerequisites[i][0];
        edgeColSize[a]++;
        edges[a] = (int*)realloc(edges[a], sizeof(int) * edgeColSize[a]);
        edges[a][edgeColSize[a]-1] = b;
        indeg[b]++;
    }
    int q[numCourses];
    int l = 0, r = -1;
    for(int i = 0; i < numCourses; i++){
        if(indeg[i] == 0){
            q[++r] = i;
        }
    }
    int cnt = 0;
    while(l <= r){
        cnt++;
        int u = q[l++];
        for(int i = 0; i < edgeColSize[u]; i++){
            int s = edges[u][i];
            indeg[s]--;
            if(indeg[s] == 0){
                q[++r] = s;
            }
        }
    }
    for(int i = 0; i < numCourses; i++){
        free(edges[i]);
    }
    free(edges);
    return cnt == numCourses;
}

时间复杂度: O(n+m)，其中 n 为课程数，m 为先修课程的要求数。这其实就是对图进行广度优先搜索的时间复杂度。
空间复杂度: O(n+m)。题目中是以列表形式给出的先修课程关系，为了对图进行广度优先搜索，我们需要存储成邻接表的形式，空间复杂度为 O(n+m)。在广度优先搜索的过程中，我们需要最多 O(n) 的队列空间（迭代）进行广度优先搜索。因此总空间复杂度为 O(n+m)。

leetcode-210.课程表 II

leetcode-210.课程表 II
现在你总共有 numCourses 门课需要选，记为 0 到 numCourses - 1。给你一个数组 prerequisites ，其中 prerequisites[i] = [ai, bi] ，表示在选修课程 ai 前 必须 先选修 bi 。

• 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示：[0,1] 。

返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序，你只要返回 任意一种 就可以了。如果不可能完成所有课程，返回 一个空数组 。

int* findOrder(int numCourses, int** prerequisites, int prerequisitesSize, int* prerequisitesColSize, int* returnSize){
    int** edges = (int**)malloc(sizeof(int*) * numCourses);
    for(int i = 0; i < numCourses; i++){
        edges[i] = (int*)malloc(0);
    }
    int edgesColSize[numCourses];
    memset(edgesColSize, 0, sizeof(edgesColSize));
    int indeg[numCourses];
    memset(indeg, 0, sizeof(indeg));
    for(int i = 0; i < prerequisitesSize; i++){
        int a = prerequisites[i][1], b = prerequisites[i][0];
        edgesColSize[a]++;
        edges[a] = (int*)realloc(edges[a], sizeof(int) * edgesColSize[a]);
        edges[a][edgesColSize[a] - 1] = b;
        indeg[b]++;
    }
    int l = 0, r = -1;
    int q[numCourses];
    for(int i = 0; i < numCourses; i++){
        if(indeg[i] == 0){
            q[++r] = i;
        }
    }
    int* res = (int*)malloc(sizeof(int) * numCourses);
    int cnt = 0;
    while(l <= r){
        int u = q[l++];
        res[cnt++] = u;
        for(int i = 0; i < edgesColSize[u]; i++){
            int to = edges[u][i];
            indeg[to]--;
            if(indeg[to] == 0){
                q[++r] = to;
            }
        }
    }
    for(int i = 0; i < numCourses; i++){
        free(edges[i]);
    }
    free(edges);
    if(cnt == numCourses){
        *returnSize = cnt;
    }
    else{
        *returnSize = 0;
    }
    return res;
}

时间复杂度: O(n+m)，其中 n 为课程数，m 为先修课程的要求数。这其实就是对图进行广度优先搜索的时间复杂度。
空间复杂度: O(n+m)。题目中是以列表形式给出的先修课程关系，为了对图进行广度优先搜索，我们需要存储成邻接表的形式，空间复杂度为 O(n+m)。在广度优先搜索的过程中，我们需要最多 O(n) 的队列空间（迭代）进行广度优先搜索，并且还需要若干个 O(n) 的空间存储节点入度、最终答案等。