08-图9 关键活动 (30分)

最新推荐文章于 2020-08-18 00:19:00 发布

Chen丶HC

最新推荐文章于 2020-08-18 00:19:00 发布

阅读量639

点赞数

CC 4.0 BY-SA版权

文章标签： PTA

本文链接：https://blog.youkuaiyun.com/chcnsn/article/details/72782722

PTA 专栏收录该内容

21 篇文章

订阅专栏

本文介绍了一种使用拓扑排序算法寻找关键路径的方法。通过建立正向与反向邻接表来计算最早时间和最迟时间，进而确定关键路径。适用于不允许活动延误的场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/*
这题就是拓扑排序找关键路径，按照陈老师所讲的算法，先建立一个正向链接的邻接表，在建立一个反向链接的邻接表
来记录出度与入读，注意关键路径是指决不允许延误的活动D<i, j> = Lt[j] - Et[i] - C<i, j>
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define Maxn 1005
#define INF -100005
#define M 100005
//建立邻接表所需的结构体
typedef struct AdjNode* AdjList;
struct AdjNode {
    int index;
    int Weight;
    AdjList Next;
};

typedef struct HNode {
    AdjList FirstEdge; 
}List[Maxn];

typedef struct GNode* LGraph;
struct GNode {
    int Nv;
    List Head;
};

typedef struct ENode* Edge;
struct ENode {
    int V1, V2;
    int Weight;
};
//建一个G2用于反向链接邻接表，便于记录出度，方便反向递推求各点的最迟时间
LGraph G2;

void InsertEdge(LGraph G, Edge E) {
    AdjList NewNode;
    NewNode = (AdjList)malloc(sizeof(struct AdjNode));
    NewNode->index = E->V2;
    NewNode->Weight = E->Weight;
    NewNode->Next = G->Head[E->V1].FirstEdge;
    G->Head[E->V1].FirstEdge = NewNode;

    NewNode = (AdjList)malloc(sizeof(struct AdjNode));
    NewNode->index = E->V1;
    NewNode->Weight = E->Weight;
    NewNode->Next = G2->Head[E->V2].FirstEdge;
    G2->Head[E->V2].FirstEdge = NewNode;
}

LGraph CreateLGraph(int n, int m) {
    int v;
    LGraph G = (LGraph)malloc(sizeof(struct GNode));
    Edge E = (Edge)malloc(sizeof(struct ENode));
    G2 = (LGraph)malloc(sizeof(struct GNode));
    G->Nv = n; G2->Nv = n;
    for(v = 1; v <= n; v++)
        { G->Head[v].FirstEdge = NULL; G2->Head[v].FirstEdge = NULL; }
    for(v = 1; v <= m; v++) {
        scanf("%d%d%d", &E->V1, &E->V2, &E->Weight);
        InsertEdge(G, E);
    }
    return G;
}

void TopSort(LGraph G) {
    int Indegree[Maxn], Outdegree[Maxn], ETime[Maxn], LTime[Maxn], cnt = 0, t = INF;
    int Q[Maxn], front, rear;
    int v;
    AdjList w;
    //计算最早时间
    front = rear = 0;
    //初始化入度数
    for(v = 1; v <= G->Nv; v++) {
        ETime[v] = 0;
        Indegree[v] = 0;
    }
    for(v = 1; v <= G->Nv; v++)
        for(w = G->Head[v].FirstEdge; w; w = w->Next)
            ++Indegree[w->index];
    //入度为零的节点入队，并应初始化起始时间为0
    for(v = 1; v <= G->Nv; v++) if(!Indegree[v]) Q[++rear] = v;
    while(rear != front) {
        v = Q[++front];
        cnt++;
        for(w = G->Head[v].FirstEdge; w; w = w->Next) {
            //Et[w] = max(Et[v] + c<i, j>)
            if(ETime[v] + w->Weight > ETime[w->index]) ETime[w->index] = ETime[v] + w->Weight;
            if(--Indegree[w->index] == 0) Q[++rear] = w->index;
        }
    }//printf("%d\n", cnt);  0
    //若多个终点，找最大时间作为整个过程最早时间
    for(v = 1; v <= cnt; v++)
            if(t < ETime[v]) t = ETime[v];
    //计算每个节点最迟时间，注意先将每个终点的最早时间改成计算出的t
    front = rear = 0;
    for(v = 1; v <= G2->Nv; v++) {
        LTime[v] = M;
        Outdegree[v] = 0;
    }
    for(v = 1; v <= G2->Nv; v++) {
        for(w = G2->Head[v].FirstEdge; w; w = w->Next)
            ++Outdegree[w->index];
    }
    for(v = 1; v <= G2->Nv; v++)
        if(!Outdegree[v]) {
            //printf("%d\n", v);
            LTime[v] = t;
            Q[++rear] = v;
        }//for(v = 1; v <= G->Nv; v++) printf("E = %d, L = %d\n", ETime[v], LTime[v]);
    while(rear != front) {
        v = Q[++front];
        for(w = G2->Head[v].FirstEdge; w; w = w->Next) {
            if(--Outdegree[w->index] == 0) Q[++rear] = w->index;
            if(LTime[w->index] > LTime[v] - w->Weight) LTime[w->index] = LTime[v] - w->Weight;
        }
    }//for(v = 1; v <= G->Nv; v++) printf("E = %d, L = %d\n", ETime[v], LTime[v]);
    if(cnt == G->Nv) {
        printf("%d\n", t);
        for(v = 1; v <= cnt; v++)
            for(w = G->Head[v].FirstEdge; w; w = w->Next)
                if(LTime[w->index] - w->Weight == ETime[v]) printf("%d->%d\n", v, w->index);
    }
    else printf("0\n");
}

int main() {
    int n, m;
    LGraph G;
    scanf("%d%d", &n, &m);
    G = CreateLGraph(n, m);
    TopSort(G);
    return 0;
}