数据结构——邻接表表示的图的关键路径算法

  
    

   
     
   
      #include 
   
     <
   
     iostream
   
     >
   
     

   
     using
   
      
   
     namespace
   
      std;

#include 
   
     <
   
     stdio.h
   
     >
   
     
#include 
   
     <
   
     stdlib.h
   
     >
   
     


   
     #define
   
      OK 1
   
     

   
     #define
   
      NULL 0
   
     

   
     #define
   
      MAX_VERTEX_NUM 20 
   
     //
   
      最大顶点数
   
     

typedef 
   
     char
   
      VertexType;
typedef 
   
     int
   
      VRType;
typedef 
   
     int
   
      InforType;
typedef 
   
     int
   
      indegree[MAX_VERTEX_NUM]; 
   
     //
   
     存放节点入度数组
   
     

   
     int
   
      
   
     *
   
     ve,
   
     *
   
     vl; 
   
     //
   
     事件最早发生时间和最迟发生时间数组，全局变量
   
     

   
     int
   
      
   
     *
   
     stack2; 
   
     //
   
     建栈存储拓扑序列
   
     

   
     int
   
      top2;


typedef 
   
     struct
   
      ArcNode
{
 
   
     int
   
      adjvex; 
   
     //
   
     该边所指的顶点的位置
   
     

   
      
   
     struct
   
      ArcNode 
   
     *
   
     nextarc; 
   
     //
   
     指向下一条边的指针
   
     

   
      
   
     int
   
      info; 
   
     //
   
     弧的长度(关键路径中的活动)
   
     

   
     }ArcNode; 
   
     //
   
     表的结点
   
     

   
     
typedef 
   
     struct
   
      VNode
{
 VertexType data; 
   
     //
   
     顶点信息（如数据等）
   
     

   
      ArcNode 
   
     *
   
     firstarc; 
   
     //
   
     指向第一条依附该顶点的边的弧指针
   
     

   
     }VNode, AdjList[MAX_VERTEX_NUM]; 
   
     //
   
     头结点
   
     

   
     
typedef 
   
     struct
   
      ALGraph
{
 AdjList vertices;
 
   
     int
   
      vexnum, arcnum; 
   
     //
   
     图的当前顶点数和弧数
   
     

   
     }ALGraph;



   
     //
   
     初始化图
   
     

   
     void
   
      init_ALGraph(ALGraph 
   
     &
   
     g)
{
 g.arcnum
   
     =
   
     0
   
     ;
 g.vexnum
   
     =
   
     0
   
     ;
}


   
     //
   
     返回顶点v在顶点向量中的位置
   
     

   
     int
   
      LocateVex(ALGraph 
   
     &
   
     G, 
   
     char
   
      v)
{
 
   
     int
   
      i;
 
   
     for
   
     (i 
   
     =
   
      
   
     0
   
     ; v 
   
     !=
   
      G.vertices[i].data 
   
     &&
   
      i 
   
     <
   
      G.vexnum; i
   
     ++
   
     )
 ;
 
   
     if
   
     (i 
   
     >=
   
      G.vexnum)
 
   
     return
   
      
   
     -
   
     1
   
     ;
 
   
     return
   
      i;
}


   
     //
   
     增加节点
   
     

   
     void
   
      add_vex(ALGraph 
   
     &
   
     G)
{
 cout
   
     <<
   
     "
   
     输入有向图顶点数: 
   
     "
   
     <<
   
     endl;
 cin
   
     >>
   
     G.vexnum;
 
   
     //
   
     getchar(); 
   
     //
   
     吃回车
   
     

   
      cout
   
     <<
   
     "
   
     输入顶点信息:
   
     "
   
     <<
   
     endl;
 
   
     for
   
     (
   
     int
   
      i 
   
     =
   
      
   
     0
   
     ; i 
   
     <
   
      G.vexnum; i
   
     ++
   
     )
 {
 cin
   
     >>
   
     G.vertices[i].data; 
   
     //
   
     构造顶点向量
   
     

   
      G.vertices[i].firstarc 
   
     =
   
      NULL;
 
   
     //
   
     getchar();
   
     

   
      }
}


   
     //
   
     增加边
   
     

   
     void
   
      add_arc(ALGraph 
   
     &
   
     G, indegree indegree)
{
 ArcNode 
   
     *
   
     s;
 ArcNode 
   
     *
   
     p;

 
   
     for
   
     (
   
     int
   
      k
   
     =
   
     0
   
     ; k
   
     <
   
     G.vexnum; k
   
     ++
   
     )
 indegree[k]
   
     =
   
     0
   
     ;

 cout
   
     <<
   
     "
   
     输入有向图边数: 
   
     "
   
     <<
   
     endl;
 cin
   
     >>
   
     G.arcnum;
 
   
     char
   
      v1, v2;
 
   
     int
   
      length;
 cout
   
     <<
   
     "
   
     输入边信息:
   
     "
   
     <<
   
     endl;
 
   
     for
   
     (k 
   
     =
   
      
   
     0
   
     ; k 
   
     <
   
      G.arcnum; k
   
     ++
   
     )
 {
 cin
   
     >>
   
     v1
   
     >>
   
     v2
   
     >>
   
     length;
 
   
     int
   
      i 
   
     =
   
      LocateVex(G, v1);
 
   
     int
   
      j 
   
     =
   
      LocateVex(G, v2); 
   
     //
   
     确定v1 , v2在G中的位置
   
     

   
      
   
     ++
   
     indegree[j]; 
   
     //
   
     点j的入度增加1
   
     

   
     
 s 
   
     =
   
      (ArcNode
   
     *
   
     ) malloc (
   
     sizeof
   
     (ArcNode));
 s
   
     ->
   
     adjvex 
   
     =
   
      j; 
   
     //
   
     该边所指向的顶点的位置为j
   
     

   
      s
   
     ->
   
     info
   
     =
   
     length;
 s
   
     ->
   
     nextarc 
   
     =
   
      NULL;
 
   
     if
   
     (
   
     !
   
     G.vertices[i].firstarc)
 {
 G.vertices[i].firstarc
   
     =
   
     s;
 }
 
   
     else
   
     
 {
 
   
     for
   
     (p 
   
     =
   
      G.vertices[i].firstarc; p
   
     ->
   
     nextarc; p 
   
     =
   
      p
   
     ->
   
     nextarc)
 ;
 p
   
     ->
   
     nextarc
   
     =
   
     s;
 }
 }
}


   
     //
   
     构造邻接链表
   
     

   
     void
   
      CreateUDN(ALGraph 
   
     &
   
     G, indegree indegree)
{
 add_vex(G); 
   
     //
   
     增加节点 
   
     

   
      add_arc(G,indegree); 
   
     //
   
     增加边 
   
     

   
     }



   
     void
   
      PrintAdjList(ALGraph 
   
     &
   
     G)
{
 
   
     int
   
      i;
 ArcNode 
   
     *
   
     p;
 cout
   
     <<
   
     "
   
     编号 顶点 邻点编号
   
     "
   
     <<
   
     endl;

 
   
     for
   
     (i 
   
     =
   
      
   
     0
   
     ; i 
   
     <
   
      G.vexnum; i
   
     ++
   
     )
 {
 cout
   
     <<
   
     "
   
      
   
     "
   
     <<
   
     i
   
     <<
   
     "
   
      
   
     "
   
     <<
   
     G.vertices[i].data
   
     <<
   
     "
   
      
   
     "
   
     ;
 
   
     for
   
     (p 
   
     =
   
      G.vertices[i].firstarc; p; p 
   
     =
   
      p
   
     ->
   
     nextarc)
 cout
   
     <<
   
     p
   
     ->
   
     adjvex
   
     <<
   
     "
   
     (
   
     "
   
     <<
   
     p
   
     ->
   
     info
   
     <<
   
     "
   
     )
   
     "
   
     <<
   
     "
   
      
   
     "
   
     ;
 cout
   
     <<
   
     endl;
 }
}


   
     //
   
     拓扑排序
   
     

   
     int
   
      TopologicalSort(ALGraph 
   
     &
   
     g, indegree indegree)
{
 
   
     //
   
     若G无回路，则输出拓扑排序序列并返回1，若有回路返回0。
   
     

   
      ArcNode 
   
     *
   
     q;
 
   
     int
   
      i,k;
 
   
     int
   
      gettop;
 top2
   
     =
   
     0
   
     ;

 ve
   
     =
   
     (
   
     int
   
      
   
     *
   
     )malloc( g.vexnum
   
     *
   
     sizeof
   
     (
   
     int
   
     ) ); 
   
     //
   
     事件最早发生时间数组
   
     

   
      
   
     for
   
     (i
   
     =
   
     0
   
     ; i
   
     <
   
     g.vexnum; i
   
     ++
   
     )
 ve[i]
   
     =
   
     0
   
     ; 
   
     //
   
     初始化
   
     

   
     
 
   
     int
   
      
   
     *
   
     stack1; 
   
     //
   
     建栈将入度为0的顶点入栈
   
     

   
      stack1
   
     =
   
     (
   
     int
   
      
   
     *
   
     )malloc( g.vexnum
   
     *
   
     sizeof
   
     (
   
     int
   
     ) );
 
   
     int
   
      top1
   
     =
   
     0
   
     ;

 stack2
   
     =
   
     (
   
     int
   
      
   
     *
   
     )malloc( g.vexnum
   
     *
   
     sizeof
   
     (
   
     int
   
     ) );
   
     //
   
     初始化拓扑序列栈
   
     

   
     
 
   
     for
   
     (i 
   
     =
   
      
   
     0
   
     ; i
   
     <
   
     g.vexnum; i
   
     ++
   
     ) 
 
   
     if
   
     (
   
     0
   
      
   
     ==
   
      indegree[i]) 
   
     //
   
     将入度为0的顶点入栈
   
     

   
      stack1[
   
     ++
   
     top1]
   
     =
   
     i;
 
   
     int
   
      count
   
     =
   
     0
   
     ;

 
   
     while
   
     (top1
   
     !=
   
     0
   
     )
 {
 gettop
   
     =
   
     stack1[top1
   
     --
   
     ];
 cout
   
     <<
   
     g.vertices[gettop].data
   
     <<
   
     "
   
     -->
   
     "
   
     ;
 count
   
     ++
   
     ; 
   
     //
   
     输出i号顶点，并计数
   
     

   
      
 stack2[
   
     ++
   
     top2]
   
     =
   
     gettop; 
   
     //
   
     将弹出的顶点序号压入拓扑序列的栈
   
     

   
     
 
   
     for
   
     (q 
   
     =
   
      g.vertices[gettop].firstarc; q; q 
   
     =
   
      q
   
     ->
   
     nextarc)
 {
 k
   
     =
   
     q
   
     ->
   
     adjvex;
 
   
     if
   
     ( 
   
     !
   
     (
   
     --
   
     indegree[k]) ) 
   
     //
   
     将i号顶点的邻接点的入度减1，如果减1后为0，则入栈
   
     

   
      stack1[
   
     ++
   
     top1]
   
     =
   
     k;
 
   
     //
   
     入栈是求ve
   
     

   
      
   
     if
   
     (ve[gettop] 
   
     +
   
      q
   
     ->
   
     info 
   
     >
   
      ve[k]) 
   
     //
   
     求各顶点事件的最早发生时间ve值
   
     

   
      ve[k] 
   
     =
   
      ve[gettop] 
   
     +
   
      q
   
     ->
   
     info;
 }
   
     //
   
     for
   
     

   
      }
   
     //
   
     while
   
     

   
      cout
   
     <<
   
     endl;
 
   
     if
   
     (count 
   
     <
   
      g.vexnum) 
   
     //
   
     有环路
   
     

   
      
   
     return
   
      
   
     1
   
     ;
 
   
     else
   
     
 
   
     return
   
      
   
     0
   
     ;
}



   
     //
   
     求关键路径
   
     

   
     void
   
      CriticalPath(ALGraph 
   
     &
   
     g, indegree indegree) 
   
     //
   
     G为有向网，输出G的各项关键活动
   
     

   
     {
 ArcNode 
   
     *
   
     q;
 
   
     int
   
      gettop,k,j;
 
   
     int
   
      ee,el; 
   
     //
   
     活动最早发生时间和最迟发生时间
   
     

   
      
 TopologicalSort(g, indegree);

 vl
   
     =
   
     (
   
     int
   
      
   
     *
   
     )malloc( g.vexnum
   
     *
   
     sizeof
   
     (
   
     int
   
     ) ); 
   
     //
   
     事件最早发生时间数组
   
     

   
      
   
     for
   
     (
   
     int
   
      i
   
     =
   
     0
   
     ; i
   
     <
   
     g.vexnum; i
   
     ++
   
     )
 vl[i]
   
     =
   
     ve[g.vexnum
   
     -
   
     1
   
     ]; 
   
     //
   
     初始化
   
     

   
      
 cout
   
     <<
   
     "
   
     ve:
   
     "
   
     <<
   
     endl; 
   
     //
   
     输出ve
   
     

   
      
   
     for
   
     (i
   
     =
   
     0
   
     ; i
   
     <
   
     g.vexnum; i
   
     ++
   
     )
 cout
   
     <<
   
     ve[i]
   
     <<
   
     "
   
      
   
     "
   
     ;
 cout
   
     <<
   
     endl;

 
   
     while
   
     (top2
   
     !=
   
     0
   
     ) 
   
     //
   
     出栈是求vl
   
     

   
      {
 gettop
   
     =
   
     stack2[top2
   
     --
   
     ];
 
   
     for
   
     (q 
   
     =
   
      g.vertices[gettop].firstarc; q; q 
   
     =
   
      q
   
     ->
   
     nextarc) 
   
     //
   
     求各顶点事件的最迟发生时间vl值
   
     

   
      {
 k
   
     =
   
     q
   
     ->
   
     adjvex;
 
   
     if
   
     (vl[k] 
   
     -
   
      q
   
     ->
   
     info 
   
     <
   
      vl[gettop])
 vl[gettop] 
   
     =
   
      vl[k] 
   
     -
   
      q
   
     ->
   
     info;
 }
   
     //
   
     for
   
     

   
      }

 cout
   
     <<
   
     "
   
     vl:
   
     "
   
     <<
   
     endl; 
   
     //
   
     输出vl
   
     

   
      
   
     for
   
     (i
   
     =
   
     0
   
     ; i
   
     <
   
     g.vexnum; i
   
     ++
   
     )
 cout
   
     <<
   
     vl[i]
   
     <<
   
     "
   
      
   
     "
   
     ;
 cout
   
     <<
   
     endl;

 
   
     for
   
     (j
   
     =
   
     0
   
     ; j
   
     <
   
     g.vexnum; j
   
     ++
   
     ) 
   
     //
   
     求ee,el和关键活动
   
     

   
      {
 
   
     for
   
     (q 
   
     =
   
      g.vertices[j].firstarc; q; q 
   
     =
   
      q
   
     ->
   
     nextarc)
 {
 k
   
     =
   
     q
   
     ->
   
     adjvex;
 ee 
   
     =
   
      ve[j]; 
   
     //
   
     活动最早发生时间
   
     

   
      el 
   
     =
   
      vl[k] 
   
     -
   
      q
   
     ->
   
     info; 
   
     //
   
     活动最迟发生时间
   
     

   
      
   
     if
   
     (ee 
   
     ==
   
      el) 
   
     //
   
     两者相等即在关键路径上
   
     

   
      cout
   
     <<
   
     g.vertices[j].data
   
     <<
   
     "
   
     到
   
     "
   
     <<
   
     g.vertices[k].data
 
   
     <<
   
     "
   
     长度为:
   
     "
   
     <<
   
     q
   
     ->
   
     info
   
     <<
   
     "
   
     发生时间为
   
     "
   
     <<
   
     ee
   
     <<
   
     endl;
 }
 }
}


   
     int
   
      main()
{
 ALGraph G;
 indegree indegree;
 init_ALGraph(G); 
   
     //
   
     初始化图
   
     

   
     
 CreateUDN(G, indegree); 
   
     //
   
     创建图
   
     

   
      PrintAdjList(G); 
   
     //
   
     打印图
   
     

   
     
 CriticalPath(G,indegree); 
   
     //
   
     求关键路径
   
     

   
      
 
   
     return
   
      
   
     0
   
     ;
}