题目描述

C 国有 n 个大城市和 m 条道路,每条道路连接这 n 个城市中的某两个城市。任意两个城市之间最多只有一条道路直接相连。这 m 条道路中有一部分为单向通行的道路,一部分为双向通行的道路,双向通行的道路在统计条数时也计为 1 条。

C 国幅员辽阔,各地的资源分布情况各不相同,这就导致了同一种商品在不同城市的价格不一定相同。但是,同一种商品在同一个城市的买入价和卖出价始终是相同的。

商人阿龙来到 C 国旅游。当他得知同一种商品在不同城市的价格可能会不同这一信息之后,便决定在旅游的同时,利用商品在不同城市中的差价赚回一点旅费。设 C 国 n 个城市的标号从 1~ n,阿龙决定从 1 号城市出发,并最终在 n 号城市结束自己的旅行。在旅游的过程中,任何城市可以重复经过多次,但不要求经过所有 n 个城市。阿龙通过这样的贸易方式赚取旅费:他会选择一个经过的城市买入他最喜欢的商品――水晶球,并在之后经过的另一个城市卖出这个水晶球,用赚取的差价当做旅费。由于阿龙主要是来 C 国旅游,他决定这个贸易只进行最多一次,当然,在赚不到差价的情况下他就无需进行贸易。

假设 C 国有 5 个大城市,城市的编号和道路连接情况如下图,单向箭头表示这条道路为单向通行,双向箭头表示这条道路为双向通行。

假设 1~n 号城市的水晶球价格分别为 4,3,5,6,1。

阿龙可以选择如下一条线路:1->2->3->5,并在 2 号城市以 3 的价格买入水晶球,在 3号城市以 5 的价格卖出水晶球,赚取的旅费数为 2。

阿龙也可以选择如下一条线路 1->4->5->4->5,并在第 1 次到达 5 号城市时以 1 的价格买入水晶球,在第 2 次到达 4 号城市时以 6 的价格卖出水晶球,赚取的旅费数为 5。

现在给出 n 个城市的水晶球价格,m 条道路的信息(每条道路所连接的两个城市的编号以及该条道路的通行情况)。请你告诉阿龙,他最多能赚取多少旅费。

输入输出格式

输入格式: 第一行包含 2 个正整数 n 和 m,中间用一个空格隔开,分别表示城市的数目和道路的数目。

第二行 n 个正整数,每两个整数之间用一个空格隔开,按标号顺序分别表示这 n 个城市的商品价格。

接下来 m 行,每行有 3 个正整数,x,y,z,每两个整数之间用一个空格隔开。如果 z=1,表示这条道路是城市 x 到城市 y 之间的单向道路;如果 z=2,表示这条道路为城市 x 和城市y 之间的双向道路。

输出格式: 输出文件 trade.out 共 1 行,包含 1 个整数,表示最多能赚取的旅费。如果没有进行贸易,则输出 0。

输入输出样例

输入样例#1: 5 5 4 3 5 6 1 1 2 1 1 4 1 2 3 2 3 5 1 4 5 2

输出样例#1: 5 说明

【数据范围】

输入数据保证 1 号城市可以到达 n 号城市。

对于 10%的数据,1≤n≤6。

对于 30%的数据,1≤n≤100。

对于 50%的数据,不存在一条旅游路线,可以从一个城市出发,再回到这个城市。

对于 100%的数据,1≤n≤100000,1≤m≤500000,1≤x,y≤n,1≤z≤2,1≤各城市

水晶球价格≤100。

NO.1 SPFA

首先明确的是先买再卖,所以要找到dis1[i] 点1到i最便宜的买入价,
dis2 点i到n最贵的卖出价,最后答案为  max(dis2[i] - dis1[i])
代码
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<stack>
#define MAXN 1000000
#define ri register int
using namespace std;

int v[MAXN];
int head[MAXN],nxt[2*MAXN],cnt = 0;
int head1[MAXN],nxt1[2*MAXN];
int a,b,c,n,m;
int vis[MAXN],dis1[MAXN],dis2[MAXN];

struct edge
{
    int f,to,c;
}qwq[2*MAXN],pre[2*MAXN];

void re(int &x)
{
    x = 0;
    char ch = getchar();
    int b = 0;
    while(ch < '0' || ch > '9'){
        if(ch == '-') b = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9'){
        x = (x << 1) + (x << 3) + ch - '0';
        ch = getchar();
    }
    if(b == -1)
        x *= -1;
}
void build(int ff,int tt,int cc)
{
    qwq[++ cnt] = (edge){ff,tt,cc};
    nxt[cnt] = head[ff];
    head[ff] = cnt;

    pre[cnt] = (edge){tt,ff,cc};
    nxt1[cnt] = head1[tt];
    head1[tt] = cnt;
}
void spfa1()
{
    queue<int>q;
    dis1[1] = v[1];
    q.push(1);
    vis[1] = 1;
    while(!q.empty()){
        int x = q.front();
        vis[x] = 0; q.pop();
        for(ri i = head[x];i;i = nxt[i]){
            edge u = qwq[i];
            if(dis1[u.to] > min(dis1[x],u.c)){
                dis1[u.to] = min(dis1[x],u.c);
                if(!vis[u.to]){
                    vis[u.to] = 1;
                    q.push(u.to);
                }
            }
        }
    }
}
void spfa2()
{
    memset(vis,0,sizeof(vis));
    queue<int>q;
    dis2[n] = v[n];
    q.push(n);
    vis[n] = 1;
    while(!q.empty()){
        int x = q.front();
        vis[x] = 0; q.pop();
        for(ri i = head1[x];i;i = nxt1[i]){
            edge u = pre[i];
            if(dis2[u.to] < max(dis2[x],u.c)){
                dis2[u.to] = max(dis2[x],u.c);
                if(!vis[u.to]){
                    vis[u.to] = 1;
                    q.push(u.to);
                }
            }
        }
    }
}
int main()
{
    re(n),re(m);
    for(ri i = 1;i <= n;i ++)
        re(v[i]);
    for(ri i = 1;i <= m;i ++){
        re(a),re(b),re(c);
        if(c == 1) build(a,b,v[b]);
        if(c == 2) build(a,b,v[b]),build(b,a,v[a]);
    }
    for(ri i = 1;i <= n;i ++){
        dis1[i] = 10000;
        dis2[i] = -10000;
    }
    spfa1();
    spfa2();
    int ans = 0;
    for(ri i = 1;i <= n;i ++)
        ans = max(ans,dis2[i] - dis1[i]);
    printf("%d",ans);
    return 0;
}

NO.2 tarjan + 拓扑 + dp

由于有双向边的存在,即某些城市可以经过多边,那么我们可以将这些城市的最大利润算出,则变成了DAG,dp即可
代码
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<queue>
#include<stack>
#include<cmath>
#define MAXN 500000
#define ri register int
using namespace std;

struct edge
{
    int f,to;
}qwq1[2*MAXN],qwq2[2*MAXN];
int n,m,v[MAXN],a,b,c;
int head1[MAXN],nxt1[2*MAXN],cnt1;
int head2[MAXN],nxt2[2*MAXN],cnt2;
int scc,col[MAXN],dfn[MAXN],low[MAXN],vis[MAXN],instack;
int in[MAXN],dep[MAXN],cntt;
int dp[MAXN],minc[MAXN],maxc[MAXN],mx[MAXN],mn[MAXN],maxx[MAXN];
stack<int>s;
queue<int>q;

inline void re(int &x)
{
    x = 0;
    char ch = getchar();
    int b = 0;
    while(ch < '0' || ch > '9'){
        if(ch == '-') b = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9'){
        x = (x << 1) + (x << 3) + ch - '0';
        ch = getchar();
    }
    if(b == -1)
        x *= -1;
}
inline void build1(int ff,int tt)
{
    qwq1[++ cnt1] = (edge){ff,tt};
    nxt1[cnt1] = head1[ff];
    head1[ff] = cnt1; 
}
inline void build2(int ff,int tt)
{
    qwq2[++ cnt2] = (edge){ff,tt};
    nxt2[cnt2] = head2[ff];
    head2[ff] = cnt2; 
}
void tarjan(int x)
{
    dfn[x] = low[x] = ++ instack;
    s.push(x);
    vis[x] = 1;
    for(ri i = head1[x];i;i = nxt1[i]){
        edge u = qwq1[i];
        if(!dfn[u.to]){
            tarjan(u.to);
            low[x] = min(low[x],low[u.to]);
        }
        else if(vis[u.to]){
            low[x] = min(low[x],dfn[u.to]);
        }
    }
    if(dfn[x] == low[x]){
        scc ++;
        int o;
        while(s.top() != x){
            o = s.top();
            vis[o] = 0;
            col[o] = scc;
            s.pop();
        }
        vis[x] = 0;
        col[x] = scc;
        s.pop();                   
    }
}
inline void DP()
{
    memset(minc,0x3f,sizeof(minc));
    minc[dep[1]] = mn[dep[1]];
    for(ri i = 1;i <= cntt;i ++){       //枚举点的遍历顺序 
            int x = dep[i];
        for(ri j = head2[x];j;j = nxt2[j]){
            int u = qwq2[j].to;
            minc[u] = min(minc[u],min(minc[x],mn[x]));
            dp[u] = max(dp[u],max(dp[x],max(maxx[u],mx[u] - minc[u])));
        }
    }

    printf("%d\n",dp[col[n]]);
}
inline void topu()
{
    for(ri i = 1;i <= scc;i ++){        //拓扑排序确定点的遍历顺序 
        if(!in[i]) q.push(i);
    }
    while(!q.empty()){
        int x = q.front();
        q.pop(); dep[++ cntt] = x;
        for(ri i = head2[x];i;i = nxt2[i]){
            edge u = qwq2[i];
            in[u.to] --;
            if(!in[u.to])
                q.push(u.to);
        }
    }
    DP();
}
int main()
{
    re(n),re(m);
    memset(mn,0x3f,sizeof(mn));
    for(ri i = 1;i <= n;i ++)
        re(v[i]);
    for(ri i = 1;i <= m;i ++){
        re(a),re(b),re(c);
        if(c == 1) build1(a,b);
        if(c == 2) build1(a,b),build1(b,a);
    }
    for(ri i = 1;i <= n;i ++)
        if(!dfn[i]) tarjan(i);      //tarjan找环 

    for(ri i = 1;i <= n;i ++)
        for(ri j = head1[i];j;j = nxt1[j]){     //缩点,重新建边 
            int u = qwq1[j].to;
            if(col[i] != col[u]){
                build2(col[i],col[u]);
                in[col[u]] ++;
            }
        }
    for(ri i = 1;i <= n;i ++){
        mx[col[i]] = max(mx[col[i]],v[i]);      //处理新图每个点的最小买入价和最大卖出价 
        mn[col[i]] = min(mn[col[i]],v[i]);
    }
    for(ri i = 1;i <= scc;i ++)                  
        maxx[i] = mx[i] - mn[i];
    topu();

    return 0;
}