拓扑排序，求深度朴素解法

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <securec.h>
#include <ctype.h>
#include <stdbool.h>
#include <errno.h>
#include "uthash.h"
#include <stdint.h>

#define MAXVEX 5000

int Max(int a, int b)
{
    return a > b ? a : b;
}

bool IsRelate(int n[], int *relations, int *maxDeep)
{
    int son = relations[1];
    int parent = relations[0]; // 我被依赖，则我的深度 + 1

    // son 依赖 parent
    // 如果 n[parent] <  n[son] + 1， 说明新的依赖造成深度增加，更新深度
    if (n[parent] < n[son] + 1) {
        n[parent] = n[son] + 1; // 我被依赖，则我的深度 = 子节点的深度 + 1， 相当于每次遍历依赖时，更新父节点的深度
        *maxDeep = Max(*maxDeep, n[parent]);
        return true;
    }

    // 当深度不再增加，说明已经处理完毕，通知上层退出
    return false;
}

int GetMinTime(int taskNum, int relationsNum, int** relations)
{
    if (taskNum == 0) {
        return 0;
    }

    int n[1001] = { 0 }; // 哈希表，表示每个顶点对应的依赖深度
    int maxDeep = 0;
    bool hasRelate = true;

    // 如果 hasRelate 为真，说明还有依赖，继续遍历
    while (hasRelate) {
        hasRelate = false; // 初始时假设没有依赖
        for (int i = 0; i < relationsNum; ++i) {
            // 如果还有依赖关系，说明没结束
            if (IsRelate(n, relations[i], &maxDeep)) {
                hasRelate = true;
            }
        }
    }

    return maxDeep + 1;
}

int minimumSemesters(int n, int** relations, int relationsSize, int* relationsColSize)
{
    return GetMinTime(n, relationsSize, relations);
}

// int main()
// {
//     int **relations = malloc(sizeof(int *) * MAXVEX);
//     relations[0] = malloc(sizeof(int) * MAXVEX);
//     relations[1] = malloc(sizeof(int) * MAXVEX);

//     relations[0][0] = 1;
//     relations[0][1] = 3;
//     relations[1][0] = 2;
//     relations[1][1] = 3;

//     int numVertexes = 3;   // 顶点数
//     int relationsSize = 2;  // 边数
//     int relationsColSize = 2; // 每条边两个顶点
//     int ret = minimumSemesters(numVertexes, relations, relationsSize, &relationsColSize);

//     printf("ret = %d\n", ret);
// }