第6章 图

图的定义：
图是由顶点的有穷非空集合和顶点之间的边组成，通常表示为：
G=(V，E)
其中：G表示一个图，V是图G中顶点的集合，E是图G中顶点之间边的集合。
*在线性表中，元素的个数可以为零，称为空表
在树中，结点个数可以为零，称为空树；
在图中，顶点个数不能为零，但可以没有边。
*简**单图：在图中，若不存在顶点到其自身的边，且同一条边不重复出现。
邻接、依附
无向图中，对于任意两个顶点vi和顶点vj，若存在边(vi，vj)，则称顶点vi和顶点vj互为邻接点，同时称边(vi，vj)依附于顶点vi和顶点vj。
有向图中，对于任意两个顶点vi和顶点vj，若存在弧<vi，vj>，则称顶点vi邻接到顶点vj，顶点vj邻接自顶点vi，同时称弧<vi，vj>依附于顶点vi和顶点vj 。

在线性结构中，数据元素之间仅具有线性关系；
在树结构中，结点之间具有层次关系；
在图结构中，任意两个顶点之间都可能有关系。
无向完全图：在无向图中，如果任意两个顶点之间都存在边，则称该图为无向完全图。
***有向完全图：***在有向图中，如果任意两个顶点之间都存在方向相反的两条弧，则称该图为有向完全图。

含有n个顶点的无向完全图有n×(n-1)/2条边。
含有n个顶点的有向完全图有n×(n-1)条边。
***权：***是指对边赋予的有意义的数值量。
***网：***边上带权的图，也称网图。
***路径：***在无向图G=(V, E)中，从顶点vp到顶点vq之间的路径是一个顶点序列(vp=vi0,vi1,vi2, …, vim=vq)，其中，(vij-1,vij)∈E（1≤j≤m）。若G是有向图，则路径也是有方向的，顶点序列满足<vij-1,vij>∈E。
一般情况下，图中的路径不惟一。
路径长度：
非带权图——路径上边的个数
带权图——路径上各边的权之和
***回路（环）：***第一个顶点和最后一个顶点相同的路径。
***简单路径：***序列中顶点不重复出现的路径。
***简单回路（简单环）：***除了第一个顶点和最后一个顶点外，其余顶点不重复出现的回路。
***子图：***若图G=（V，E），G’=（V’，E’），如果V’V 且E’  E ，则称图G’是G的子图。
***连通图：***在无向图中，如果从一个顶点vi到另一个顶点vj(i≠j)有路径，则称顶点vi和vj是连通的。如果图中任意两个顶点都是连通的，则称该图是连通图。
***连通分量：***非连通图的极大连通子图称为连通分量
***强连通图：***在有向图中，对图中任意一对顶点vi和vj (i≠j)，若从顶点vi到顶点vj和从顶点vj到顶点vi均有路径，则称该有向图是强连通图。
***强连通分量：***非强连通图的极大强连通子图
***生成树：***n个顶点的连通图G的生成树是包含G中全部顶点的一个极小连通子图。
***生成森林：***在非连通图中，由每个连通分量都可以得到一棵生成树，这些连通分量的生成树就组成了一个非连通图的生成森林。
图的遍历操作
图的遍历是从图中某一顶点出发，对图中所有顶点访问一次且仅访问一次。
在图中，如何选取遍历的起始顶点？
解决方案：从编号小的顶点开始 。
从某个起点始可能到达不了所有其它顶点，怎么办？
解决方案：多次调用从某顶点出发遍历图的算法
因图中可能存在回路，某些顶点可能会被重复访问，那么如何避免遍历不会因回路而陷入死循环?
解决方案：附设访问标志数组visited[n] 。
在图中，一个顶点可以和其它多个顶点相连，当这样的顶点访问过后，如何选取下一个要访问的顶点？
解决方案：深度优先遍历和广度优先遍历。
1. 深度优先遍历 （DFS：Depth First Search）
⑴ 访问顶点v；
⑵ 从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；
⑶ 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。
深度优先搜索是带回溯的
许多问题的解决都是通过深度优先搜索方法解决的
2. 广度优先遍历 （BFS：Broad First Search ；FIFO: First In First Out）
⑴ 访问顶点v；
⑵ 依次访问v的各个未被访问的邻接点v1, v2, …, vk；
⑶ 分别从v1，v2，…，vk出发依次访问它们未被访问的邻接点，并使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问。直至图中所有与顶点v有路径相通的顶点都被访问到。
图的存储结构及实现
1、邻接矩阵（数组表示法）
用一个一维数组存储图中顶点的信息
用一个二维数组（称为邻接矩阵）存储图中各顶点之间的邻接关系。
const int MaxSize=10;
template
class Mgraph{
public:
MGraph(T a[ ], int n, int e );
~MGraph( )
void DFSTraverse(int v);
void BFSTraverse(int v);
……
private:
T vertex[MaxSize];
int arc[MaxSize][MaxSize];
int vertexNum, arcNum;
};
template
MGraph::MGraph(T a[ ], int n, int e) {
vertexNum=n; arcNum=e;
for (i=0; i<vertexNum; i++)
vertex[i]=a[i];
for (i=0; i<vertexNum; i++) //初始化邻接矩阵
for (j=0; j<vertexNum; j++)
arc[i][j]=0;
for (k=0; k<arcNum; k++) {
cin>>i>>j; //边依附的两个顶点的序号
arc[i][j]=1; arc[j][i]=1; //置有边标志
}
}
int visited[MaxSize]; //深度优先遍历
template
void MGraph::DFSTraverse(int v){
cout<<vertex[v]; visited [v]=1;
for (j=0; j<vertexNum; j++)
if (arc[v][j]==1 && visited[j]==0)
DFSTraverse( j );
}
int visited[MaxSize]; //广度优先遍历
template
void MGraph::BFSTraverse(int v){
front=rear=-1; //假设采用顺序队列且不会发生溢出
int Q[MaxSize]; cout<<vertex[v]; visited[v]=1; Q[++rear]=v;
while (front!=rear) {
v=Q[++front];
for (j=0; j<vertexNum; j++)
if (arc[v][j]==1 && visited[j]==0 ) {
cout<<vertex[j]; visited[j]=1; Q[++rear]=j;
}
}
}
2、邻接表
对于图的每个顶点vi，将所有邻接于vi的顶点链成一个单链表，称为顶点vi的边表（对于有向图则称为出边表）
所有边表的头指针和存储顶点信息的一维数组构成了顶点表。
struct ArcNode{
int adjvex;
ArcNode *next;
};
template
struct VertexNode{
T vertex;
ArcNode *firstedge;
};
const int MaxSize=10; //图的最大顶点数
template
class ALGraph
{
public:
ALGraph(T a[ ], int n, int e);
~ALGraph;
void DFSTraverse(int v);
void BFSTraverse(int v);
…
private:
VertexNode adjlist[MaxSize];
int vertexNum, arcNum;
};
template
ALGraph::ALGraph(T a[ ], int n, int e)
{
vertexNum=n; arcNum=e;
for (i=0; i<vertexNum; i++)
{
adjlist[i].vertex=a[i];
adjlist[i].firstedge=NULL;
}
for (k=0; k<arcNum; k++)
{
cin>>i>>j;
s=new ArcNode; s->adjvex=j;
s->next=adjlist[i].firstedge;
adjlist[i].firstedge=s;
}
}
template
void ALGraph::DFSTraverse(int v){
cout<<adjlist[v].vertex; visited[v]=1;
p=adjlist[v].firstedge;
while (p!=NULL) {
j=p->adjvex;
if (visited[j]==0) DFSTraverse(j);
p=p->next;
}
}
template
void ALGraph::BFSTraverse(int v){
front=rear=-1;
cout<<adjlist[v].vertex; visited[v]=1; Q[++rear]=v;
while (front!=rear) {
v=Q[++front]; p=adjlist[v].firstedge;
while (p!=NULL) {
j= p->adjvex;
if (visited[j]==0) {
cout<<adjlist[j].vertex; visited[j]=1; Q[++rear]=j;
}
p=p->next;
}
}
}
最小生成树（minimal spanning tree）
生成树的代价：设G=（V，E）是一个无向连通网，生成树上各边的权值之和称为该生成树的代价。
*最小生成树：*在图G所有生成树中，代价最小的生成树称为最小生成树。
普里姆（Prim）算法
设G=(V, E)是具有n个顶点的连通网，
T=(U, TE)是G的最小生成树，
T的初始状态为U={u0}（u0∈V），TE={ }，
重复执行下述操作：
在所有u∈U，v∈V-U的边中找一条代价最小的边(u, v)并入集合TE，同时v并入U，直至U=V。
*数组lowcost[n]：*用来保存集合V-U中各顶点与集合U中顶点最短边的权值，lowcost[v]=0表示顶点v已加入最小生成树中
*数组adjvex[n]：*用来保存该边所依附的（集合V-U中各顶点与集合U中顶点的最短边）集合U中的顶点
Void prime(MGraph G){
for(int i=1;i<G.vertexNu;i++){
lowcost[i]=G.arc[0][i]; adjvex[i]=0;
}
lowcost[0]=0;
for(i=1;i<G.vertexNum;i+++){
k=MinEdge(lowcost,G.vertexNum)
cout<<K<<adjvex[k]<<lowcost[k];
lowcost[k]=0;
for(j=1;j<G.vertexNum;j++)
if((G.arc[k][j]<lowcost[j]){
lowcost[j]=G.arc[k][j];
arcvex[j]=k;
}
}
}
Kruskal算法

1. 初始化：U=V； TE={ }；
2. 循环直到T中的连通分量个数为1
   2.1 在E中寻找最短边(u，v);
   2.2 如果顶点u、v位于T的两个不同连通分量，则
   2.2.1 将边(u，v)并入TE；
   2.2.2 将这两个连通分量合并为一个；
   2.3 在E中标记边(u，v)，使得(u，v)不参加后续最短边的选取；
   采用边集数组存储图。
   定义Parent[i]数组。数组分量的值表示顶点i的双亲节点（初值为-1；） 当一条边（u,v）的两个顶点的根结不同时，这两个结点属于不同的连通分量（利用parent 数组查找一棵树的根节点。当一个结点n的parent==-1，树的根节点即为n）
   要进行联通分量的合并 ，其中一个顶点所在的树的根节点为vex1，另一个顶点所在的树的根节点为vex2，则：parent[vex2]=vex1；
   int main(){
   int arcNum, int vertexNum;
   EdgeNode *edge;
   int *parent;
   cout<<“please input the number of vertexNum:”; cin>>vertexNum;
   cout<<“please input the number of edges:”; cin>>arcNum;
   edge=new EdgeNode[arcNum]; parent=new int[vertexNum];
   for(int i=0;i<arcNum;i++) {
   cout<<“Please input the edges:”;
   cin>>edge[i].from>>edge[i].to>>edge[i].weight;
   }
   sort(edges, G); //对边集数组进行堆排序，时间复杂性为O(eloge)
   for (i=0;i<vertexNum;i++)
   parent[i]=-1; //每个节点分属于不同的集合
   int k=0,begin,end,count=0;
   cout<<“next is the MST :”<<endl;
   for (k=0;k<arcNum;k++) {
   begin=edge[k].from; end=edge[k].to;
   int m,n;
   m=Find(parent,begin); n=Find(parent,end);
   if(m!=n) {
   cout<<begin<<","<<end<<","<<edge[k].weight<<endl;
   parent[n]=m;
   count++;
   if(count==vertexNum-1) break;
   }
   }
   return 0;
   }
   int Find(int *parent, int node)
   {
   int f;
   f=node;
   while(parent[f]>-1)
   f=parent[f];
   return f;
   }
   最短路径
   在非网图中，最短路径是指两顶点之间经历的边数最少的路径。
   在网图中，最短路径是指两顶点之间经历的边上权值之和最短的路径。
   1、设置一个集合S存放已经找到最短路径的顶点，S的初始状态只包含源点v，
   2、对vi∈V-S，假设从源点v到vi的有向边为最短路径（从v到其余顶点的最短路径的初值）。
   3、以后每求得一条最短路径v, …, vk，就将vk加入集合S中，并将路径v, …, vk , vi与原来的假设相比较，取路径长度较小者为最短路径。
   4、重复上述过程，直到集合V中全部顶点加入到集合S中。

onst 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算法

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网
拓扑序列：
设G=(V，E)是一个具有n个顶点的有向图，V中的顶点序列v1, v2, …, vn称为一个拓扑序列，当且仅当满足下列条件：若从顶点vi到vj有一条路径，则在顶点的拓扑序列中顶点vi必在顶点vj之前。
*拓扑排序：*对一个有向图构造拓扑序列的过程称为拓扑排序 。
⑴ 从AOV网中选择一个没有前驱的顶点并且输出；
⑵ 从AOV网中删去该顶点，并且删去所有以该顶点为尾的弧；
⑶ 重复上述两步，直到全部顶点都被输出，或AOV网中不存在没有前驱的顶点。
基于邻接表的拓扑排序的基本思想
1）找G中无前驱的顶点
查找indegree ［i］为零的顶点vi；
2）修改邻接于顶点i的顶点的入度（删除以i为起点的所有弧）
对链在顶点i后面的所有邻接顶点k，将对应的indegree［k］ 减1。
为了避免重复检测入度为零的顶点，可以再设置一个辅助栈，若某一顶点的入度减为0，则将它入栈。每当输出某一入度为0的顶点时，便将它从栈中删除
void TOpSort(){
int top=-1, count=0;
for(int i=0;i<vertexnum;i++)
if(adjlist[i].in0) 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].in0) s[top++]=k;
p=p->next;
}
}
If (count<vertexNum) cout<<“有回路”；
}
AOE网
一个表示工程的带权有向图中，用顶点表示事件，用有向边表示活动，边上的权值表示活动的持续时间，称这样的有向图叫做边表示活动的网，简称AOE网。
AOE网中没有入边的顶点称为始点（或源点），没有出边的顶点称为终点（或汇点）。
AOE网的性质：
⑴ 只有在某顶点所代表的事件发生后，从该顶点出发的各活动才能开始；
⑵ 只有在进入某顶点的各活动都结束，该顶点所代表的事件才能发生。
*关键路径：*在AOE网中，从始点到终点具有最大路径长度（该路径上的各个活动所持续的时间之和）的路径称为关键路径。
*关键活动：*关键路径上的活动称为关键活动
⑴ 事件的最早发生时间ve[k]
ve[k]是指从始点开始到顶点vk的最大路径长度。
这个长度决定了所有从顶点vk发出的活动能够开工的最早时间。
⑵ 事件的最迟发生时间vl[k]
vl[k]是指在不推迟整个工期的前提下,事件vk允许的最晚发生时间。
⑶ 活动的最早开始时间e[i]
若活动ai是由弧<vk , vj>表示，则活动ai的最早开始时间应等于事件vk的最早发生时间，因此，有： e[i]=ve[k] 。
or(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];
}
无向图的连通性

要想判定一个无向图是否为连通图，或有几个连通分量，通过对无向图遍历即可得到结果。
联通图：仅需从图中任一顶点出发，进行深度优先搜索（或连广度优先搜索），便可访问到图中所有顶点。
非连通图：需从多个顶点出发进行搜索，而每一次从一个新的起始点出发进行搜索过程中得到的顶点访问序列恰为其各个连通分量中的顶点集。