关于图的各种问题及操作

一、图的连通性问题

（一）无向图判断连通性
求连通分量个数求解图是否连通。
1.count=0;
2. for (图中每个顶点v)
2.1 if (v尚未被访问过)
2.1.1 count++;
2.1.2 从v出发遍历该图（函数调用）；
3. if (count==1) cout<<“图是连通的”;
else cout<<“图中有”<<count<<“个连通分量”;

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

（三）生成树
生成树的代价：设G=（V，E）是一个无向连通网，生成树上各边的权值之和称为该生成树的代价。
最小生成树：在图G所有生成树中，代价最小的生成树称为最小生成树。
MST性质：假设G=(V, E)是一个无向连通网，U是顶点集V的一个非空子集。若(u, v)是一条具有最小权值的边，其中u∈U，v∈V－U，则必存在一棵包含边(u, v)的最小生成树。
最小生成树构造方法：
1.Prime法：加点法

 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;
            }
    }
}

2.Kruskal方法：加边法

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.单源点到其他顶点的最短路径：Dijkstra方法，O（n2）

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];
            }
    }
}

2.任意一对顶点之间的最短路径：Floyed方法，O（n3）

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]!=INF)
                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];
                }
}

（五）拓扑排序

**1.AOV网：**在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，称这样的有向图为顶点表示活动的网，简称AOV网。
拓扑序列：
设G=(V，E)是一个具有n个顶点的有向图，V中的顶点序列v1, v2, …, vn称为一个拓扑序列，当且仅当满足下列条件：若从顶点vi到vj有一条路径，则在顶点的拓扑序列中顶点vi必在顶点vj之前。
拓扑排序：
对一个有向图构造拓扑序列的过程称为拓扑排序 。
⑴ 从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<<“有回路”；
}

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

• ⑴ 事件的最早发生时间ve[k]
• ⑵ 事件的最迟发生时间vl[k]
• ⑶ 活动的最早开始时间e[i]
• ⑷ 活动的最晚开始时间l[i]

存储结构：

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]的计算

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]的计算

 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]

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

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

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];
}