第三届河南省程序设计大赛-NYOJ-247-虚拟的城市之旅（SPFA）

虚拟的城市之旅
时间限制：3000 ms | 内存限制：65535 KB
难度：6
描述
展馆是未来城市的缩影，个人体验和互动是不变的主题。在A国展馆通过多维模式和高科技手段，引领参观者在展示空间踏上一段虚拟的城市之旅。
梦幻国有N个城市和M条道路，每条道路连接某两个城市。任意两个城市之间最多只有一条道路直接相连。这M条道路中有一部分为单向通行的道路，一部分为双向通行的道路。
梦幻国幅员辽阔，各地的资源分布情况各不相同，这就导致了同一种商品在不同城市的价格不一定相同。但是，同一种商品在同一个城市的买入价和卖出价始终是相同的。

现在你已踏上一段虚拟的城市之旅。为了给你一个意外收获，允许你在旅游的同时，利用 X 商品在不同城市中的差价赚回一点旅费，但最多只能交易一次。即,在某个城市买入X 商品，可以走到另外一个城市买掉来获得旅费。当然，在赚不到差价的情况下，你也可以不进行贸易活动。
设梦幻国N个城市的标号从1~ N，你只能从1 号城市出发，并最终在N 号城市结束自己的旅行。在旅游的过程中，任何城市可以重复经过多次，但不要求经过所有N个城市。
例如：梦幻国有5个大城市，城市的编号和道路连接情况如下图，单向箭头表示这条道路为单向通行，双向箭头表示这条道路为双向通行。假设 X 商品在1~5 号城市的价格分别为 4，3，5，6，1。
你可以选择如下一条线路：1235，并在2 号城市以3 的价格买入X 商品，在3号城市以5 的价格卖出X 商品，赚取的旅费数为2。
你也可以选择如下一条线路14545，并在第1次到达5号城市时以1的价格买入X 商品，在第2次到达4号城市时以6 的价格卖出X 商品，赚取的旅费数为5。
现在给出N个城市的X 商品价格，M条道路的信息（每条道路所连接的两个城市的编号以及该条道路的通行情况）。请问你能赚取尽可能多的旅费吗。
输入
有多组测试数据（以EOF为文件结束的标志）
每组测试数据的格式如下：
第一行：N M 分别表示城市的数目和道路的数目。
第二行：N个正整数，每两个整数之间用一个空格隔开，分别表示1到N个城市的商品价格。
接下来 M行，每行有3个正整数，X，Y，Z，每两个整数之间用一个空格隔开。
如果 Z=1，表示这条道路是城市X到城市Y之间的单向道路；
如果Z=2，表示这条道路为城市X 和城市Y之间的双向道路。

1≤N≤100000，1≤M≤500000，
1≤X，Y≤N，1≤Z≤2，1≤商品价格≤100。
输出
输出1个整数，表示最多能赚取的旅费。如果没有进行贸易，则输出0。
样例输入
5 5
4 3 5 6 1
1 2 1
1 4 1
2 3 2
3 5 1
4 5 2
样例输出
5

思路：一遍1~N的SPFA，标记出可访问的点以及这些点的进价，一遍N~1的SPFA，标记可访问的点以及这些点的售价，然后从1~N遍历一遍找到最大差价即可。

此题写了五天，坑点甚多。
刚开始只想着两边SPFA后找最大差价即可，已知WA，刚想到找差价时还要判断该点是否可到达！果断把vis设为全局数组，即可标记该点是否进入过队列，有可判断该点是否可到达。

代码

#include<stdio.h>
#include<string.h>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;
//SPFA一遍1~N求最小进价
//SPFA一遍N~1求最大售价
const int maxn=100005;
const int INF=0x3f3f3f3f;
int min_cost[maxn];
int max_cost[maxn];
bool vis_positive[maxn];//标记是否被访问，同时标记该点是否可到达
bool vis_reverse[maxn];
int N,M;
struct node
{
    int v;
    node *next;
};
node *List_positive[maxn];
node *List_reverse[maxn];
void Add_Edge(int u,int v)
{
    node *temp=new node;
    temp->v=v;
    if(List_positive[u]==NULL)
    {
        List_positive[u]=temp;
        temp->next=NULL;
    }
    else
    {
        temp->next=List_positive[u];
        List_positive[u]=temp;
    }
    node *flag=new node;
    flag->v=u;
    if(List_reverse[v]==NULL)
    {
        List_reverse[v]=flag;
        flag->next=NULL;
    }
    else
    {
        flag->next=List_reverse[v];
        List_reverse[v]=flag;
    }
}
void Init_List()
{
    for(int i=1; i<=N; i++)
    {
        for(node *temp=List_positive[i]; temp!=NULL; temp=List_positive[i])
        {
            List_positive[i]=temp->next;
            delete temp;
        }
    }
    for(int i=N; i>=1; i--)
    {
        for(node *temp=List_reverse[i]; temp!=NULL; temp=List_reverse[i])
        {
            List_reverse[i]=temp->next;
            delete temp;
        }
    }

}
void SPFA()
{
    memset(vis_positive,false,sizeof(vis_positive));
    vis_positive[1]=true;
    queue<int>q;
    q.push(1);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(node *temp=List_positive[u]; temp!=NULL; temp=temp->next)
        {
            min_cost[temp->v]=min(min_cost[temp->v],min_cost[u]);
            if(vis_positive[temp->v]==false)
            {
                q.push(temp->v);
                vis_positive[temp->v]=true;
            }
        }
    }
    memset(vis_reverse,false,sizeof(vis_reverse));
    vis_reverse[N]=true;
    q.push(N);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(node *temp=List_reverse[u]; temp!=NULL; temp=temp->next)
        {
            max_cost[temp->v]=max(max_cost[temp->v],max_cost[u]);
            if(vis_reverse[temp->v]==false)
            {
                q.push(temp->v);
                vis_reverse[temp->v]=true;
            }
        }
    }
}
int main()
{
    while(scanf("%d%d",&N,&M)!=EOF)
    {
        for(int i=1; i<=N; i++)
        {
            scanf("%d",&min_cost[i]);
            max_cost[i]=min_cost[i];
        }
        while(M--)
        {
            int u,v,flag;
            scanf("%d%d%d",&u,&v,&flag);
            Add_Edge(u,v);
            if(flag==2)
                Add_Edge(v,u);
        }
        SPFA();
        int result=0;
        for(int i=1; i<=N; i++)
            if(vis_positive[i]&&vis_reverse[i])
                result=max(result,max_cost[i]-min_cost[i]);
        printf("%d\n",result);
        Init_List();
    }
    return 0;
}