Heavy Transportation POJ

#include<string>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;

/*
spfa算法主要用了bellom-ford算法中，所以对于任意一条最短路径，
若一次迭代后未新增已确认顶点，
则该最短路径上不会再新增已确认顶点。
bellom-ford算法所以图处于任意一种状态时，
若图中尚存在未确认顶点，则执行一次迭代后，
会增加至少一个已确认顶点。

若某条最短路径上的最后一个顶点存在未确认相邻顶点，
经过一次迭代松弛后，若经过该顶点的最短路径上未新增已确认顶点，
则无论后续经过多少次迭代松弛，
经过该顶点的最短路径上都不会新增已确认顶点，
即该条路径已经走到头了。
所以在保证k条边以内的最短距离，可以用这个

*/
//spfa
const int maxn=1000+10,INF=0x3f3f3f3f;
int d[maxn],vis[maxn],num[maxn];
struct Node
{
    int v,value;
    Node() {}
    Node(int a,int b)
    {
        v=a;
        value=b;
    }
};
int n,m;
vector<Node>G[maxn];
bool spfa(int s)
{
    queue<int>que;
    que.push(s);
    d[s]=INF;
    num[s]++;
    while(!que.empty())
    {
        int v=que.front();
        que.pop();
        vis[v]=0;
        for(int i=0; i<G[v].size(); i++)
        {
            Node node1=G[v][i];
            int u=node1.v;
            int value=d[u];
            d[u]=max(d[u],min(d[v],node1.value));
            if(!vis[u]&&value<d[u])
            {
                que.push(u);
                vis[u]=1;
            }
        }
    }
}

int main()
{
    int t;
    scanf("%d",&t);
    int kase=0;
    while(t--)
    {
        scanf("%d%d",&n,&m);
        int a,b,c;
        memset(d,0,sizeof d);
        memset(vis,0,sizeof vis);
        memset(num,0,sizeof num);
        for(int i=1; i<=n; i++)
            G[i].clear();
        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            G[a].push_back(Node(b,c));
            G[b].push_back(Node(a,c));
        }
        spfa(1);
        if(n!=1)
            printf("Scenario #%d:
%d

",++kase,d[n]);
        else
            printf("Scenario #%d:
0

",++kase);
    }
    return 0;
}