AOE关键路径

这个算法来求关键路径，其实就是利用拓扑排序，首先求出，每个节点最晚开始时间，再倒退求每个最早开始的时间。

从而算出活动最早开始的时间和最晚开始的时间，如果这两个时间相等，则为关键路径。

时间复杂度为O(n+e)

主要算法：

int topSort(Graph *g){
    EdgeNode *e;
    int i,k,gettop;
    int top = 0 ;
    int count = 0;
    int *stack;
    stack = (int *)malloc(g->numVertexes * sizeof(int));
    for(i=0;i<g->numVertexes;i++){ 
        if(g->headlist[i].in == 0) //把入度为0的，即没有入度的点入栈
            stack[++top] = i;
    }

    top2 = 0;
    etv = (int *)malloc(g->numVertexes*sizeof(int));
    for(i=0;i<g->numVertexes;i++){
        etv[i] = 0;
    }
    stack2=(int *)malloc(g->numVertexes*sizeof(int));

    while(top){
        gettop = stack[top--];
        printf("%d ",gettop);
        count++;
        stack2[++top2] = gettop;

        for(e = g->headlist[gettop].fnode; e ; e=e->next){ //一次遍历链表，减少各个子节点的入度
            k = e->data;
            if(!(--g->headlist[k].in))
                stack[++top] = k;
            if((etv[gettop]+e->weight)>etv[k]) //选取最大值
                etv[k] = etv[gettop]+e->weight;
        }
    }
    if(count < g->numVertexes)
        return ERROR;
    else
        return OK;
}

int critical(Graph *g){
    EdgeNode *e;
    int i,gettop,k,j;
    int ete,lte;

    topSort(g);
    printf("\n-------------------------------------------\n");
    for(i=0;i<g->numVertexes;i++){
        printf("%d ",etv[i]);
    }
    printf("\n-------------------------------------------\n");
    ltv = (int *)malloc(sizeof(int)*g->numVertexes);
    for(i=0;i<g->numVertexes;i++){
        ltv[i] = etv[g->numVertexes-1];
    }

    while(top2!=0){
        gettop = stack2[top2--];
        for(e = g->headlist[gettop].fnode;e;e = e->next){
            k = e->data;
            if(ltv[k]-e->weight < ltv[gettop]){
                ltv[gettop] = ltv[k] - e->weight;
            }
        }
    }
    
    for(i=0;i<g->numVertexes;i++){
        printf("%d ",ltv[i]);
    }
    printf("\n-------------------------------------------\n");
    printf("\n");
    for(j=0;j<g->numVertexes;j++){
        for(e=g->headlist[j].fnode; e; e=e->next){
            k = e->data;
            ete = etv[j];//活动最早
            lte = ltv[k] - e->weight;//活动最迟
            if(ete == lte)
                printf("<v%d v%d>length:%d\n",g->headlist[j].data,g->headlist[k].data,e->weight);
        }
    }
    return 1;
}

全部代码：

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <string.h>
  4 #define MAX 9
  5 #define ERROR 1
  6 #define OK 0
  7 typedef struct edgeNode{
  8     int data;
  9     int weight;
 10     struct edgeNode *next;
 11 }EdgeNode;
 12 typedef struct headNode{
 13     int in;
 14     int data;
 15     EdgeNode *fnode;
 16 }HeadNode,HeadList[MAX];
 17 typedef struct{
 18     HeadList headlist;
 19     int numEdges,numVertexes;
 20 }Graph,*graph;
 21 
 22 int *etv,*ltv;
 23 int *stack2;
 24 int top2;
 25 
 26 void initialGraph(Graph *g);
 27 void headinfo(Graph *g,int in,int node);
 28 void linkinfo(Graph *g,int node,int link,int weight);
 29 void printGraph(Graph *g);
 30 int topSort(Graph *g);
 31 int critical(Graph *g);
 32 
 33 int main(){
 34     Graph *g = (Graph *)malloc(sizeof(Graph));
 35     g->numEdges = 0;
 36     g->numVertexes = 0;
 37     initialGraph(g);
 38     printGraph(g);
 39 
 40     critical(g);
 41     //topSort(g);
 42 
 43     getchar();
 44     return 0;
 45 }
 46 int critical(Graph *g){
 47     EdgeNode *e;
 48     int i,gettop,k,j;
 49     int ete,lte;
 50 
 51     topSort(g);
 52     printf("\n-------------------------------------------\n");
 53     for(i=0;i<g->numVertexes;i++){
 54         printf("%d ",etv[i]);
 55     }
 56     printf("\n-------------------------------------------\n");
 57     ltv = (int *)malloc(sizeof(int)*g->numVertexes);
 58     for(i=0;i<g->numVertexes;i++){
 59         ltv[i] = etv[g->numVertexes-1];
 60     }
 61 
 62     while(top2!=0){
 63         gettop = stack2[top2--];
 64         for(e = g->headlist[gettop].fnode;e;e = e->next){
 65             k = e->data;
 66             if(ltv[k]-e->weight < ltv[gettop]){
 67                 ltv[gettop] = ltv[k] - e->weight;
 68             }
 69         }
 70     }
 71     
 72     for(i=0;i<g->numVertexes;i++){
 73         printf("%d ",ltv[i]);
 74     }
 75     printf("\n-------------------------------------------\n");
 76     printf("\n");
 77     for(j=0;j<g->numVertexes;j++){
 78         for(e=g->headlist[j].fnode; e; e=e->next){
 79             k = e->data;
 80             ete = etv[j];//活动最早
 81             lte = ltv[k] - e->weight;//活动最迟
 82             if(ete == lte)
 83                 printf("<v%d v%d>length:%d\n",g->headlist[j].data,g->headlist[k].data,e->weight);
 84         }
 85     }
 86     return 1;
 87 }
 88 
 89 int topSort(Graph *g){
 90     EdgeNode *e;
 91     int i,k,gettop;
 92     int top = 0 ;
 93     int count = 0;
 94     int *stack;
 95     stack = (int *)malloc(g->numVertexes * sizeof(int));
 96     for(i=0;i<g->numVertexes;i++){ 
 97         if(g->headlist[i].in == 0) //把入度为0的，即没有入度的点入栈
 98             stack[++top] = i;
 99     }
100 
101     top2 = 0;
102     etv = (int *)malloc(g->numVertexes*sizeof(int));
103     for(i=0;i<g->numVertexes;i++){
104         etv[i] = 0;
105     }
106     stack2=(int *)malloc(g->numVertexes*sizeof(int));
107 
108     while(top){
109         gettop = stack[top--];
110         printf("%d ",gettop);
111         count++;
112         stack2[++top2] = gettop;
113 
114         for(e = g->headlist[gettop].fnode; e ; e=e->next){ //一次遍历链表，减少各个子节点的入度
115             k = e->data;
116             if(!(--g->headlist[k].in))
117                 stack[++top] = k;
118             if((etv[gettop]+e->weight)>etv[k]) //选取最大值
119                 etv[k] = etv[gettop]+e->weight;
120         }
121     }
122     if(count < g->numVertexes)
123         return ERROR;
124     else
125         return OK;
126 }
127 
128 void printGraph(graph g){
129     int i;
130     printf("vertex:%d,edges:%d\n",g->numVertexes,g->numEdges);
131     EdgeNode *e = (EdgeNode *)malloc(sizeof(EdgeNode));
132     for(i=0;i<MAX;i++){
133         printf("[in:%d]%d",g->headlist[i].in,g->headlist[i].data);    
134         e = g->headlist[i].fnode;
135         while(e != NULL){    
136             printf("->%d(%d)",e->data,e->weight);
137             e = e->next;
138         }    
139         printf("\n");
140     }
141     free(e);
142 }
143 void initialGraph(Graph *g){
144     headinfo(g,0,0);
145     linkinfo(g,0,2,4);
146     linkinfo(g,0,1,3);
147 
148     headinfo(g,1,1);
149     linkinfo(g,1,3,5);
150     linkinfo(g,1,4,6);
151 
152     headinfo(g,1,2);
153     linkinfo(g,2,3,8);
154     linkinfo(g,2,5,7);
155 
156     headinfo(g,2,3);
157     linkinfo(g,3,4,3);
158 
159     headinfo(g,2,4);
160     linkinfo(g,4,6,9);
161     linkinfo(g,4,7,4);
162 
163     headinfo(g,1,5);
164     linkinfo(g,5,7,6);
165 
166     headinfo(g,1,6);
167     linkinfo(g,6,9,2);
168 
169     headinfo(g,2,7);
170     linkinfo(g,7,8,5);
171 
172     headinfo(g,1,8);
173     linkinfo(g,8,9,3);
174 
175     headinfo(g,2,9);
176 }
177 void headinfo(Graph *g,int in,int node){
178     g->headlist[node].in = in;
179     g->headlist[node].data = node;
180     g->headlist[node].fnode = NULL;
181     g->numVertexes++;
182 }
183 void linkinfo(Graph *g,int node,int link,int weight){
184     EdgeNode *en = (EdgeNode *)malloc(sizeof(EdgeNode));
185     if(g->headlist[node].fnode != NULL){
186         en->next = g->headlist[node].fnode;
187     }else{
188         en->next = NULL;
189     }
190     g->headlist[node].fnode = en;
191     en->data = link;
192     en->weight = weight;
193     g->numEdges++;
194 }

View Code

运行示例：