最短路径

在非网图中，最短路径是指两顶点之间经历的边数最少的路径。
在网图中，最短路径是指两顶点之间经历的边上权值之和最短的路径。

最短路径问题
单源点到其他顶点的最短路径
Dijkstra方法，O（n2）
任意一对顶点之间的最短路径
Floyed方法，O（n3）

Dijkstra算法
基本思想：
1、设置一个集合S存放已经找到最短路径的顶点，S的初始状态只包含源点v，
2、对vi∈V-S，假设从源点v到vi的有向边为最短路径（从v到其余顶点的最短路径的初值）。
3、以后每求得一条最短路径v, …, vk，就将vk加入集合S中，并将路径v, …, vk , vi与原来的假设相比较，取路径长度较小者为最短路径。
重复上述过程，直到集合V中全部顶点加入到集合S中。
第一条最短路的特点：一定是直达的边，且只含一条权值最小的边。
下一条路径长度次短的最短路径的特点：①直达的边②从源点经过顶点v1再到达该顶点。

数据结构
图的存储结构：邻接矩阵存储结构
数组dist[n]：每个分量dist[i]表示当前所找到的从始点v到终点vi的最短路径的长度。初态为：
若从v到vi有弧，则dist[i]为弧上权值；否则置dist[i]为∞。
数组path[n]：path[i]是一个字符串，表示当前所找到的从始点v到终点vi的最短路径。初态为：若从v到vi有弧，则path[i]为vvi；否则置path[i]空串。
数组s[n]：存放源点和已经找到最短路径的终点，其初态为只有一个源点v。

const int MAX=1000;
void  Dijkstra(MGraph g, int v){
       for ( i =0; i<g.vexnum ; i++){
  dist[i]=g.arcs[v][i];  
               if ( dist[i]!= MAX) 
                      path [i]=g.vertex[v]+g.vertex[i];
               else
                      path[i]=“”;
       }
       S[0]=g.vertex[v]; 
       num=1;  
       While (num<g.vextexNum){
    k=0;
    for(i=0;i<G.vertexNum;i++)
           if((dist[i]<dist[k])   k=i
    cout<<dist[k]<<path[k];
    s[num++]=G.vertex[k];                
    for(i=0;i<G.vertexNum;i++)
             if(dist[k]+g.arc[k][i]<dist[i] {
   dist[i]=dist[k]+g.arc[k][i];
                       path[i]=path[k]+g.vertex[i];
               }
}
}

Floyd算法

图的存储结构：带权的邻接矩阵存储结构。
数组dist[n][n]：存放在迭代过程中求得的最短路径长度。
数组path[n][n]：存放从vi到vj的最短路径，初始为path[i][j]=“vivj”。

void Floyd(MGraph G)
{
    for (i=0; i<G.vertexNum; i++)        
    for (j=0; j<G.vertexNum; j++)
    {
  dist[i][j]=G.arc[i][j];
        if (dist[i][j]!=∞) 
          path[i][j]=G.vertex[i]+G.vertex[j];
        else 
         path[i][j]=""; 
       }
       for (k=0; k<G.vertexNum; k++)         
         for (i=0; i<G.vertexNum; i++)       
           for (j=0; j<G.vertexNum; j++)
               if (dist[i][k]+dist[k][j]<dist[i][j]) {
                    dist[i][j]=dist[i][k]+dist[k][j];
                    path[i][j]=path[i][k]+path[k][j];
              }
}

AOV网
AOV网：在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，称这样的有向图为顶点表示活动的网，简称AOV网。
AOV网特点：
1.AOV网中的弧表示活动之间存在的某种制约关系。
2.AOV网中不能出现回路 。

拓扑序列：
设G=(V，E)是一个具有n个顶点的有向图，V中的顶点序列v1, v2, …, vn称为一个拓扑序列，当且仅当满足下列条件：若从顶点vi到vj有一条路径，则在顶点的拓扑序列中顶点vi必在顶点vj之前。
拓扑排序：对一个有向图构造拓扑序列的过程称为拓扑排序 。
拓扑序列使得AOV网中所有应存在的前驱和后继关系都能得到满足。
基本思想：
⑴ 从AOV网中选择一个没有前驱的顶点并且输出；
⑵ 从AOV网中删去该顶点，并且删去所有以该顶点为尾的弧；
⑶ 重复上述两步，直到全部顶点都被输出，或AOV网中不存在没有前驱的顶点。

void TOpSort(){
int  top=-1, count=0;
for(int i=0;i<vertexnum;i++)
     if(adjlist[i].in==0) s[++top]=i;
while(top!=-1){
    j=s[top--]; cout <<adjlist[j].vertext;   count++;
    p=adjlist[j].firstedge;
    while(p!=NULL){
          k=p->adjvex; adjlist[k].in--;
         if(adjlist[k].in==0) s[top++]=k;
         p=p->next;
      } 
}
If (count<vertexNum) cout<<“有回路”；
}

关键路径
AOE网：
在一个表示工程的带权有向图中，
用顶点表示事件，
用有向边表示活动，
边上的权值表示活动的持续时间，
称这样的有向图叫做边表示活动的网，简称AOE网。
AOE网中没有入边的顶点称为始点（或源点），没有出边的顶点称为终点（或汇点）。
AOE网的性质：
⑴ 只有在某顶点所代表的事件发生后，从该顶点出发的各活动才能开始；
⑵ 只有在进入某顶点的各活动都结束，该顶点所代表的事件才能发生。
关键路径：在AOE网中，从始点到终点具有最大路径长度（该路径上的各个活动所持续的时间之和）的路径称为关键路径。
关键活动：关键路径上的活动称为关键活动。

与关键活动有关的量
⑴ 事件的最早发生时间ve[k]
⑵ 事件的最迟发生时间vl[k]
⑶ 活动的最早开始时间e[i]
⑷ 活动的最晚开始时间l[i]
各个活动的时间余量 l[k] - e[k]，时间余量为0者即为关键活动。
存储结构的选择：①邻接矩阵可以方便的查找邻接点，完成时间的最早和最晚发生时间的计算。②边集数组可以方便的计算时间的活动的最晚发生时间。

struct Edge{
	int from;
	int to;
	int e;
	int l;
};
class Grap{
 int vertexnum,e;
 int **adjlist;   //邻接矩阵
 int start,end;
 Edge *edge;  //边集数组
public:
 Grap(int n,int e);
 int  path();
};

⑴ 事件的最早发生时间ve[k]
ve[k]是指从始点开始到顶点vk的最大路径长度。这个长度决定了所有从顶点vk发出的活动能够开工的最早时间。
①ve[1]=0
②ve[k]=max{ve[j]+len<vj, vk>} (<vj, vk>∈p[k])
③p[k]表示所有到达vk的有向边的集合

 q.push(0);//源点事件入队
 for(j=0;j<vertexnum;j++) {  //初始化每个事件最早发生时间
  ve[j]=0; visit[j]=0; }
 visit[0]=1; 
     while(!q.empty()) {  
  i=q.front();       //利用标准模板库中的队列实现
  q.pop();
  for(j=0;j<vertexnum;j++){//计算i的邻接点的ve
   if(adjlist[i][j]!=9999 && ve[i]+adjlist[i][j]>ve[j] ){
    ve[j]=ve[i]+adjlist[i][j];
    if(!visit[j])   //如果j没有被访问过，顶点j入队
     q.push(j);
    visit[j]=1;
   }
  }
 }

⑵ 事件的最迟发生时间vl[k]

vl[k]是指在不推迟整个工期的前提下,事件vk允许的最晚发生时间。

①vl[n]=ve[n]

②vl[k]=min{vl[j]-len<vk , vj>}（<vk, vj>∈s[k]）

③s[k]为所有从vk发出的有向边的集合

q.push(vertexnum-1);
 for(j=0;j<vertexnum;j++) {
  vl[j]=ve[vertexnum-1]; visit[j]=0; }
    while(!q.empty()) {
  i=q.front();
  q.pop();
  for(j=0;j<vertexnum;j++) {
   if(adjlist[j][i]!=9999 && vl[i]-adjlist[j][i]<vl[j] ){
    vl[j]=vl[i]-adjlist[j][i];
    if(!visit[j])
     q.push(j);
    visit[j]=1;
   }
  }
 }

⑶ 活动的最早开始时间e[i]

若活动ai是由弧<vk , vj>表示，则活动ai的最早开始时间应等于事件vk的最早发生时间。因此，有：e[i]=ve[k]

for(i=0;i<e;i++)
	{
		edge[i].e=ve[edge[i].from];
	}

⑷ 活动的最晚开始时间l[i]

活动ai的最晚开始时间是指，在不推迟整个工期的前提下， ai必须开始的最晚时间。

若ai由弧<vk，vj>表示，则ai的最晚开始时间要保证事件vj的最迟发生时间不拖后。

因此，有：l[i]=vl[j]-len<vk, vj>

for(i=0;i<e;i++)
 {
  edge[i].e=ve[edge[i].from];
  edge[i].l=vl[edge[i].to]-adjlist[edge[i].from][edge[i].to];
  if(edge[i].e==edge[i].l)
   cout<<edge[i].from<<"  "<<edge[i].to<<endl;
 }

图的连通性

连通图：仅需从图中任一顶点出发，进行深度优先搜索（或广度优先搜索），便可访问到图中所有顶点。

求无向图的连通分量（非连通图的遍历方法）
 - count=0;
 -  for (图中每个顶点v)
       2.1 if (v尚未被访问过) 
             2.1.1 count++;
             2.1.2 从v出发遍历该图（函数调用）；
 -  if (count==1) cout<<"图是连通的";
     else cout<<"图中有"<<count<<"个连通分量";

有向图
⑴ 从某顶点出发进行深度优先遍历，并按其所有邻接点都访问完（即出栈）的顺序将顶点排列起来。
⑵ 从最后完成访问的顶点出发，沿着以该顶点为头的弧作逆向的深度优先遍历。若不能访问到所有顶点，则从余下的顶点中最后访问的那个顶点出发，继续作逆向的深度优先遍历，直至有向图中所有顶点都被访问到为止。