数据结构实验——图之关键路径

图的关键路径实验

题目描述
关键路径算法是在AOE网中，从起点到终点最长的路径长度（由于要将所有的活动都完成才算是结束，所以只有按照最长时间的活动路径来计算），其中长度指的是路径上边的权重和。如下图所示，红色路径代表AOE网中的一条关键路径。

你的任务是输入一个带权有向图，然后判断该带权有向图是否是AOE网，如果是AOE网则输出关键活动的长度和，否则输出false。（注意：AOE网无回路，有且仅有一个起点和一个终点。一个图的起点和终点可通过顶点的入度和出度寻求出来。）

输入描述
第1行：输入图的顶点数n和边数e（默认顶点序号和名称为0~n-1，顶点数不超过10边数不超过20）。
第2~e+1行：输入i、j和w（i与j分别代表顶点i和顶点j的序号，以此形成一条有向边，有向边的箭头指向顶点j，w代表边的权重）。

输出描述
如果带权有向图是AOE网，则关键活动的长度和，否则输出false。

样例输入
5 5
0 1 7
0 3 7
0 4 1
1 3 2
3 4 10

样例输出
false

允许最长运行时间
1000ms
允许使用最大内存
64MB

oj通过91%
//参考了CSDN的一篇博文找不到了
代码如下：

#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#define MAXn 20
using namespace std;

struct node
{
    int v, cost;
    node(int _v, int _cost) : v(_v), cost(_cost) {}
};

int ve[MAXn];
int vl[MAXn];
int n, e;
int indegree[MAXn] = { 0 };
int outdegree[MAXn] = { 0 };
vector<node> adj[MAXn];
vector<int> path[MAXn];
stack<int> s;
int j = 0;  //汇点的编号

bool topologicalsort()//证明是否有回路
{
    queue<int> q;
    for (int i = 0; i < n; i++)
    {
        if (indegree[i] == 0)
        {
            q.push(i);
        }
    }
    int num = 0;
    while (!q.empty())
    {
        for (int i = 0; i < n; i++)
        {
            if (indegree[i] >= 1 && outdegree[i] >= 1)
                num++;
        }
        int u = q.front();
        q.pop();
        s.push(u);
  
        int size = adj[u].size();
        for (int i = 0; i < size; i++)
        {
            int v = adj[u][i].v;
            indegree[v]--;
            if (indegree[v] == 0)
            {
                q.push(v);
            }
            if (ve[u] + adj[u][i].cost > ve[v])
            {
                ve[v] = ve[u] + adj[u][i].cost;
            }
           
        }
    }
    int size0 = s.size();
  // cout << "s0:"<<size0<<endl;
    if (size0 == n) return true;
    else return false;
}

int criticalpath()
{
    fill(ve, ve + MAXn, 0);
    if (!topologicalsort())return -1;
    int maxlength = 0;

    for (int i = 0; i < n; i++)
    {
        if (ve[i] > maxlength)
        {
            maxlength = ve[i];
            j = i;
        }
    }

    fill(vl, vl + MAXn, maxlength);

    while (!s.empty())
    {
        int u = s.top();
        s.pop();
        int size = adj[u].size();
        for (int i = 0; i < size; i++)
        {
            int v = adj[u][i].v;
            if (vl[v] - adj[u][i].cost < vl[u])
            {
                vl[u] = vl[v] - adj[u][i].cost;
            }
        }
    }

    for (int u = 0; u < n; u++)
    {
        for (int i = 0; i < (int)adj[u].size(); i++)
        {
            int v = adj[u][i].v;
            int cost = adj[u][i].cost;
            int e = ve[u], l = vl[v] - cost;
            if (e == l)
            {
                //printf("%d --> %d\n",u, v);
                path[u].push_back(v);
            }
        }
    }
    return ve[j];
}

int main()
{
    cin >> n >> e;
    int u1, v1, w1;
    for (int i = 0; i < e; i++)
    {
        cin >> u1 >> v1 >> w1;
        adj[u1].push_back(node(v1, w1));
        indegree[v1]++;
        outdegree[u1]++;
    }
    int count = 1;//连通分量
   // topologicalsort();
    for (int i = 0; i < n; i++)
    {
        if (indegree[i] == 0 && outdegree[i] == 0)
            count++;
    }
   //cout << "count:"<<count<<endl;
    int ans = criticalpath();
    if ( count == 1 &&ans!=-1)
    {
        cout <<ans;
    }
    else
        cout << "false";
    return 0;
}