[P1073][NOIP2009T3] 最优贸易 (最短路+分层图 或 双向最短路)

题意：有一个图，既有单向边也有双向边，每个点有点权，边没有权值，求从一个点到另一个点的权值差（为正数）的最大值；

解法：最短路+分层图 或 双向SPFA；

1.最短路+分层图；可以很明显地看到如果想要赚钱，那么就要能从起点-->买入点-->卖出点-->终点，难点就是你能否经过买入点和卖出点，而分层图可以很好地解决这个问题；   我们可以建三个图，在每个图之间地连 “0” 边，第一个图连向第二个图的边的权值是第一个图上的 u的 val，第二个图连向第三个图的边的权值是第二个图上的 u的 val，最后将第一个图和第三个图的最后一个点用 “0” 边连向一个超级终点，然后跑一边最短路就行了；

2.双向最短路；正向跑一个最小值，反向跑一个最大值，最后对于图上的每一个点的 maxn - minn 求最大值，这就是答案；（记得建两个相反的图）

附上代码：

1.最短路+分层图：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
#define pr pair<int ,int >
using namespace std;
const int N = 5e5+10;
const int inf = 0x3f3f3f3f;

inline int read(){
    int ref=0,x=1;char ch=getchar();
    while(!isdigit(ch)) ch=getchar();
    while(isdigit(ch)) ref=ref*10+ch-'0',ch=getchar();
    return ref*x;
}

int n,m,k,s,t;
struct edge{
    int next,to,w;
}a[N<<4];
int head[N],cnt;
int dis[N<<4],vis[N<<4],val[N];
int ans=inf;

void add(int u,int v,int w){
    a[++cnt]=(edge){head[u],v,w};
    head[u]=cnt;
}

void ADD(int u,int v){
    add(u,v,0);
    add(u+n,v+n,0);
    add(u+2*n,v+2*n,0);
    add(u,v+n,val[u]);
    add(u+n,v+2*n,-val[u]);
}

void spfa(int x){
    memset(dis,inf,sizeof(dis));
    queue<int > q;
    q.push(x);
    dis[x]=0,vis[x]=1;
    while(!q.empty()){
        int temp=q.front();
        q.pop();
        vis[temp]=0;
        for(int i=head[temp];i;i=a[i].next){
            int v=a[i].to;
            if(dis[v]>dis[temp]+a[i].w){
                dis[v]=dis[temp]+a[i].w;
                if(!vis[v]) q.push(v),vis[v]=1;
            }
        }
    }
}

int main()
{
    n=read(),m=read();
    for(int i=1;i<=n;++i) val[i]=read();
    for(int i=1;i<=m;++i){
        int x,y,z;
        x=read(),y=read(),z=read();
        ADD(x,y);
        if(z==2) ADD(y,x);
    }
    add(n,n*3+1,0),add(n*3,n*3+1,0);
    spfa(1);
    for(int i=0;i<=k;++i) ans=min(ans,dis[n+i*n]);
    printf("%d",-dis[n*3+1]);
    return 0;
}

2.双向最短路：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
#define pr pair<int ,int >
using namespace std;
const int N = 5e5+10;
const int inf = 0x3f3f3f3f;

inline int read(){
    int ref=0,x=1;char ch=getchar();
    while(!isdigit(ch)) ch=getchar();
    while(isdigit(ch)) ref=ref*10+ch-'0',ch=getchar();
    return ref*x;
}

int n,m;
struct edge{
    int next,to;
}a[N<<4],b[N<<4];
int head[N<<4],head2[N<<4],cnt,cnt2;
int vis[N],val[N],f[N],dp[N];
int ans;

void add(int u,int v){
    a[++cnt]=(edge){head[u],v};
    head[u]=cnt;
}

void add2(int u,int v){
    b[++cnt2]=(edge){head2[u],v};
    head2[u]=cnt2;
}

void dijkstra1(){
    priority_queue<pr ,vector<pr> ,greater<pr> > q;
    memset(f,inf,sizeof(f));
    q.push(make_pair(val[1],1));
    f[1]=val[1];
    while(!q.empty()){
        int x=q.top().second;
        q.pop();
        if(vis[x]) continue;
        vis[x]=1;
        for(int i=head[x];i;i=a[i].next){
            int v=a[i].to;
            f[v]=min(f[x],val[v]);
            q.push(make_pair(f[v],v));
        }
    }
}

void dijkstra2(){
    priority_queue<pr ,vector<pr> ,less<pr> > q;
    memset(vis,0,sizeof(vis));
    q.push(make_pair(val[n],n));
    dp[n]=val[n];
    while(!q.empty()){
        int x=q.top().second;
        q.pop();
        if(vis[x]) continue;
        vis[x]=1;
        for(int i=head2[x];i;i=b[i].next){
            int v=b[i].to;
            dp[v]=max(dp[x],val[v]);
            q.push(make_pair(dp[v],v));
        }
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i) val[i]=read();
    for(int i=1;i<=m;++i){
        int x,y,z;
        x=read(),y=read(),z=read();
        add(x,y),add2(y,x);
        if(z==2) add(y,x),add2(x,y);
    }
    dijkstra1();
    dijkstra2();
    for(int i=1;i<=n;++i) ans=max(ans,dp[i]-f[i]);
    printf("%d",ans);
    return 0;
}