SDUT 2498 AOE网上的关键路径

点击打开题目链接

表示交了好多WA，逆序建图，逆序建图，逆序建图，说了三遍，目测应该够了，悲哀啊，顺序建就是不好存路径，悲哀啊！！！！

//SPFA
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define N 10010
using namespace std;

struct Arcnode
{
    int to;
    int weight;
    Arcnode *next;
};

Arcnode *List[N*5];

queue<int>Q;
int n, m;
int ans, flag;
int dis[N*5];
int path[N*5];
bool vis[N*5];
int Indegree[N];
int Outdegree[N];

void SPFA(int st)
{
    int u;
    memset(path, 0, sizeof(path));
    memset(vis, 0, sizeof(vis));
    memset(dis, 0, sizeof(dis));
    vis[st] = 1;
    Arcnode *tmp;
    Q.push(st);
    while(!Q.empty())
    {
        u = Q.front(), Q.pop(), vis[u] = 0;
        tmp = List[u];
        while(tmp)
        {
            int v = tmp -> to;
            if(dis[v] < dis[u] + tmp -> weight)
            {
                dis[v] = dis[u] + tmp -> weight;
                path[v] = u;
                if(!vis[v])
                {
                    vis[v] = 1;
                    Q.push(v);
                }
            }
            if(dis[v] == dis[u] + tmp -> weight && u < path[v])
            {
                path[v] = u;
                if(!vis[v])
                {
                    vis[v] = 1;
                    Q.push(v);
                }
            }
            tmp = tmp -> next;
        }
    }
    cout << dis[ans] << endl;
    int k = ans;
    while(path[k] != 0)
    {
        cout << k << ' ' << path[k] << endl;
        k = path[k];
    }
}

int main()
{
    while(cin >> n >> m)
    {
        memset(Indegree, 0, sizeof(Indegree));
        memset(Outdegree, 0, sizeof(Outdegree));
        memset(List, 0, sizeof(List));
        while( m --)
        {
            int u, v, w;
            cin >> u >> v >> w;
            Indegree[u] ++;
            Outdegree[v] ++;
            Arcnode *tmp = new Arcnode;
            tmp -> to = u;
            tmp -> weight = w;
            tmp -> next = NULL;
            if(List[v] == NULL) List[v] = tmp;
            else
            {
                tmp -> next = List[v];
                List[v] = tmp;
            }

        }
        for(int i = 1; i <= n; i++)
        {
            if(Indegree[i] == 0) flag = i;
            if(Outdegree[i] == 0) ans = i;
        }
        SPFA(flag);
    }
    return 0;
}

//Bellman_Ford
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

struct edge
{
    int u, v, w;
} Edge[50010];


int n, m, k;
int ans;
int path[50010];
int dis[50010];
int Outdegree[50010];

void Bellman_Ford(int st);

int main()
{
    while(~scanf("%d %d", &n, &m))
    {
        memset(Edge, 0, sizeof(Edge));
        memset(Outdegree, 0, sizeof(Outdegree));
        for(int i = 1; i <= m; i++)
        {
            int u, v, w;
            scanf("%d %d %d", &u, &v, &w);
            Edge[i].u = v, Edge[i].v = u, Edge[i].w = w;
            Outdegree[v] ++;
        }

        for(int i = 1; i <= n; i++)
        {
            if(Outdegree[i] == 0)  {ans = i; break}
        }
        Bellman_Ford();
    }
    return 0;
}


void Bellman_Ford()
{
    memset(dis, 0, sizeof(dis));
    memset(path, 0, sizeof(path));
    for(int j = 2; j <= n; j++)//从dis(1)[u]递推出dis(2)[u]......dis(n)[n].（忘了注释，差点把自己搞蒙了．．．悲哀，还是加上吧）
    {
    int tmp = 0;//排除冗余情况
    for(int i = 1; i <= m; i++)
     {

       if(dis[Edge[i].u] + Edge[i].w > dis[Edge[i].v] || (dis[Edge[i].u] + Edge[i].w == dis[Edge[i].v]
          &&Edge[i].u < path[Edge[i].v]))
        {
         dis[Edge[i].v] = dis[Edge[i].u] + Edge[i].w;
         path[Edge[i].v] = Edge[i].u;
         tmp = 1;
        }
     }
     if(tmp == 0) break;
    }
    printf("%d\n", dis[ans]);
    int k = ans;
    while(path[k] != 0)
    {
        printf("%d %d\n", k, path[k]);
        k = path[k];
    }
}
 

唉，心好累．．．．．．