第十章 数据结构专题 —— 图（下）

第十章    数据结构专题 —— 图（下）

10.6 拓扑排序

如果有一个有向图的任意顶点都无法通过一些有向边回到自身，那么称这个有向图为有向无环图（Directed Acyclic Graph，DAG）

拓扑排序是将有向无环图G的所有顶点排成一个线性序列，使得对图G的任意两个顶点u、v，如果存在边u->v , 那么在序列中u一定在v前面。这个序列又称为拓扑序列。

vector <int> G[MAXV];
int n,m,inDegree[MAXV];	//顶点数，入度

bool topologicalSort(){
	int num=0;
	queue<int> q;
	for(int i=0;i<n;i++){
		if(inDegree[i] == 0){
			q.push(i); //将所有入度为0的顶点入队
		}
	}
	while(!q.empty()){
		int u = q.front();	//取队首顶点u
		//printf("%d",u);	此处可输出顶点u，作为拓扑序列中的顶点
		q.pop();
		for(int i=0;i<G[u].size();i++){
			int v=G[u][i];	//u的后继结点v
			inDegree[v]--;	//顶点v的入度减1
			if(inDegree[v] == 0){
				q.push(v);
			}
		}
		G[u].clear();	//清空顶点u的所有出边（如无必要可以不写）
		num++;		//加入拓扑序列的顶点数加1
	}
	if(num == n) return true;	//加入拓扑序列的顶点数为n，说明拓扑排序成功
	else return false;		//加入拓扑序列的顶点数小于n，说明拓扑序列失败
}

拓扑排序可以判断一个给定的图是否是有向无环图。

如果要求有多个入度为0的顶点，选择编号较小的顶点，那么把queue改成priority_queue，并保持队首元素（堆顶元素）是优先队列中最小的元素即可（用set也可以实现）

10.7 关键路径

10.7.1 AOV网和AOE网

顶点活动（Activity On Vertex，AOV）网是指顶点表示活动，而用边集表示活动间优先关系的有向图。

边活动（Activity On Edge，AOE）网是指用带权的边集表示活动，而用顶点表示事件的有向图，其中边权表示完成活动的时间

10.7.2 最长路径

对于一个没有正环的图（指从源点可达的正环，下同），如果需要求最长路径长度，则可以把所有边的边权乘以-1，令其为相反数，然后使用Bellman-Ford算法或SPFA算法求最短路径长度，将所得结果取反即可。

如果图中有正环，那么最长路径是不存在的，但是，如果求最长简单路径（也就是每个顶点最多只经过一次的路径），那么虽然最长简单路径本身存在，却没有办法通过Bellman-Ford等算法求解，原因是最长路径问题是NP-Hard问题

最长路径问题，即Longest Path Problem，寻求的是图中的最长简单路径

而如果求的是有向无环图的最长路径长度，则下面的算法更高效

10.7.3 关键路径

求解有向无环图（DAG）中最长路径问题

活动的最早开始时间等于活动的最迟开始时间，则此活动为关键活动

#include <iostream>
#include <stack>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;

const int MAXN = 1010;	//最大顶点数
const int MAXM = 10010;	//最大边数

struct Edge{
	int v,w;
	int id;
	int next;
}edge[MAXM];

int n,m;
int cnt;

int first[MAXN],topo[MAXN];
int inDegree[MAXN],outDegree[MAXN];
int tot;
int Ee[MAXN],El[MAXN],E[MAXN],L[MAXN];
/*Ee表示事件最早可能发生时间，El表示事件最迟允许发生时间*/
/*E表示活动最早可能发生时间，L表示活动最迟允许发生时间*/

void init()
{
    cnt = 0;
    tot = 0;
    memset(first, -1, sizeof(first));
    memset(inDegree, 0, sizeof(inDegree));
    memset(outDegree, 0, sizeof(outDegree));
    memset(Ee, 0, sizeof(Ee));
    memset(E, 0, sizeof(E));
    memset(L, 0, sizeof(L));
}

void read_graph(int u, int v, int w, int id)
{
    edge[cnt].v = v, edge[cnt].w = w, edge[cnt].id = id;
    edge[cnt].next = first[u], first[u] = cnt++;
}

void toposort() //拓扑排序
{
    queue<int> q;
    for(int i = 0; i < n; i++) if(!inDegree[i]) q.push(i);
    while(!q.empty())
    {
        int x = q.front(); q.pop();
        topo[++tot] = x;
        for(int e = first[x]; e != -1; e = edge[e].next)
        {
            int v = edge[e].v, w = edge[e].w;
            if(--inDegree[v] == 0) q.push(v);
            if(Ee[v] < Ee[x] + w) //求出各个顶点Ee值
            {
                Ee[v] = Ee[x] + w;
            }
        }
    }
}

void CriticalPath()
{
    toposort();
    int top = tot;
    int Max = 0;
    for(int i = 0; i < n; i++) Max = max(Max, Ee[i]); //注意，初始化时为Ee中的最大值，否则会报错。
    for(int i = 0; i < n; i++) El[i] = Max;
    while(top) //逆拓扑排序求顶点El的值
    {
        int x = topo[top--];
        for(int e = first[x]; e != -1; e = edge[e].next)
        {
            int v = edge[e].v, w = edge[e].w;
            if(El[x] > El[v] - w)
            {
                El[x] = El[v] - w;
            }
        }
    }
    for(int u = 0; u < n; u++) //求出E,L关键活动
    {
        for(int e = first[u]; e != -1; e = edge[e].next)
        {
            int v = edge[e].v, id = edge[e].id, w = edge[e].w; //id代表活动的标号
            E[id] = Ee[u], L[id] = El[v] - w;
            if(E[id] == L[id]) //相等一定是关键活动
            {
                printf("a%d : %d->%d\n", id, u, v);
            }
        }
    }
}

void read_case()
{
    init();
    for(int i = 1; i <= m; i++)
    {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        read_graph(u, v, w, i); //read_graph
        outDegree[u]++, inDegree[v]++;
    }
}

int main()
{
    while(~scanf("%d%d", &n, &m))
    {
        read_case();
        printf("\nThe Critical activities are:\n");
        CriticalPath();
    }
    return 0;
}