找关键路径：SDUTOJ2498 AOE网上的关键路径

题目描述：

一个无环的有向图称为无环图（Directed Acyclic Graph），简称DAG图。
    AOE(Activity On Edge)网：顾名思义，用边表示活动的网，当然它也是DAG。与AOV不同，活动都表示在了边上，如下图所示：

 如上所示，共有11项活动（11条边），9个事件（9个顶点）。整个工程只有一个开始点和一个完成点。即只有一个入度为零的点（源点）和只有一个出度为零的点（汇点）。
    关键路径：是从开始点到完成点的最长路径的长度。路径的长度是边上活动耗费的时间。如上图所示，1 到2 到 5到7到9是关键路径（关键路径不止一条，请输出字典序最小的），权值的和为18。

输入：

         这里有多组数据，保证不超过10组，保证只有一个源点和汇点。输入一个顶点数n(2<=n<=10000),边数m(1<=m <=50000),接下来m行，输入起点sv，终点ev,权值w（1<=sv,ev<=n,sv != ev,1<=w <=20)。数据保证图连通。

输出：

         关键路径的权值和，并且从源点输出关键路径上的路径（如果有多条，请输出字典序最小的）。

解题思路：

        关键路径就是从源点到汇点权值最大的那一条路径，可以根据SPFA算法求得，由于关键路径不止一条，要求输出字典序最小，通过更改SPFA算法中的更新条件可以求得。

解题步骤：

        1、处理输入数据，使用链式前向星存储这个AOE网，并统计每个结点的出度和入度。

        2、找出这个网中的源点和汇点，将源点送入SPFA算法：修改SPFA算法中的更新条件，当最大路径小更新，若相等，前驱的字典序小更新，并且在每次更新是记录前驱；

        3、输出路径有两种思路：使用SPFA算法容易之间找前驱不容易找后继，可以反向建图后，依次输入前驱；或者正向建图用递归。

代码实现：

#include <iostream>
#include <queue>
using namespace std;
#define maxn 10005
#define maxe 50010

int m, n;
int head[maxn], cnt;
bool vis[maxn];
int indegree[maxn], outdegree[maxn], pre[maxn], dis[maxn];

class Edge
{
public:
    int to;
    int weight;
    int next;
};
Edge edge[maxe];

void InsertEdge(const int& u, const int& v, const int& w)
{
    edge[++cnt].to = v;
    edge[cnt].weight = w;
    edge[cnt].next = head[u];
    head[u] = cnt;
}

void CreateGraph()
{
    int u, v, w;
    cin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        cin >> u >> v >> w;
        InsertEdge(u, v, w);
        indegree[v]++;
        outdegree[u]++;
    }
}

void SPFA(int u)
{
    queue<int> q;
    q.push(u);
    dis[u] = 0;
    vis[u] = true;
    while (!q.empty())
    {
        int x = q.front();
        q.pop();
        vis[x] = false;
        for (int i = head[x]; i; i = edge[i].next)
        {
            int v = edge[i].to;
            if (dis[v] < dis[x] + edge[i].weight || ((dis[v] = dis[x] + edge[i].to) && pre[v] > x))
            {
                dis[v] = dis[x] + edge[i].weight;
                pre[v] = x;
                if (!vis[v])
                {
                    q.push(v);
                    vis[v] = true;
                }
            }
        }
    }
}

void Output(int i)
{
    if (!pre[i])
    {
        return;
    }
    Output(pre[i]);
    cout << pre[i] << " " << i << endl;
}

int main()
{
    CreateGraph();
    int start_vex = 0, end_vex = 0;
    for (int i = 1; i <= n; i++)
    {
        if (!indegree[i])
        {
            start_vex = i;
        }
        if (!outdegree[i])
        {
            end_vex = i;
        }
    }
    SPFA(start_vex);
    cout << dis[end_vex] << endl;
    Output(end_vex);

    return 0;
}