P1073 最优贸易

最优贸易

https://www.luogu.org/problemnew/show/P1073 （题目链接）

题目

C 国有 n 个大城市和 m 条道路，每条道路连接这 n 个城市中的某两个城市。任意两个
城市之间最多只有一条道路直接相连。这 m 条道路中有一部分为单向通行的道路，一部分
为双向通行的道路，双向通行的道路在统计条数时也计为 1 条。
C 国幅员辽阔，各地的资源分布情况各不相同，这就导致了同一种商品在不同城市的价
格不一定相同。但是，同一种商品在同一个城市的买入价和卖出价始终是相同的。
商人century来到 C 国旅游。当他从strork处得知同一种商品在不同城市的价格可能会不同这一信息
之后，便决定在旅游的同时，利用商品在不同城市中的差价赚回一点旅费。设 C 国 n 个城
市的标号从 1~ n，century决定从 1 号城市出发，并最终在 n 号城市结束自己的旅行。在旅游的
过程中，任何城市可以重复经过多次，但不要求经过所有 n 个城市。century通过这样的贸易方
式赚取旅费：他会选择一个经过的城市买入他最喜欢的商品——AWP，并在之后经过的另
一个城市卖出这个AWP，用赚取的差价当做旅费。由于century主要是来 C 国旅游，他决定
这个贸易只进行最多一次，当然，在赚不到差价的情况下他就无需进行贸易。
假设 C 国有 5 个大城市，城市的编号和道路连接情况如下图，单向箭头表示这条道路
为单向通行，双向箭头表示这条道路为双向通行。

假设 1~n 号城市的AWP价格分别为 4，3，5，6，1。
century可以选择如下一条线路：1->2->3->5，并在 2 号城市以 3 的价格买入AWP，在 3
号城市以 5 的价格卖出AWP，赚取的旅费数为 2。
century也可以选择如下一条线路 1->4->5->4->5，并在第 1 次到达 5 号城市时以 1 的价格
买入AWP，在第 2 次到达 4 号城市时以 6 的价格卖出AWP，赚取的旅费数为 5。

现在给出 n 个城市的AWP价格，m 条道路的信息（每条道路所连接的两个城市的编号
以及该条道路的通行情况）。请你告诉century，他最多能赚取多少旅费。

输入格式 Input Format
第一行包含 2 个正整数 n 和 m，中间用一个空格隔开，分别表示城市的数目和道路的
数目。
第二行 n 个正整数，每两个整数之间用一个空格隔开，按标号顺序分别表示这 n 个城
市的商品价格。
接下来 m 行，每行有 3 个正整数，x，y，z，每两个整数之间用一个空格隔开。如果 z=1，
表示这条道路是城市 x 到城市 y 之间的单向道路；如果 z=2，表示这条道路为城市 x 和城市
y 之间的双向道路。

输出格式 Output Format
输出共 1 行，包含 1 个整数，表示最多能赚取的旅费。如果没有进行贸易，
则输出 0。

样例输入 Sample Input
5 5
4 3 5 6 1
1 2 1
1 4 1
2 3 2
3 5 1
4 5 2

样例输出 Sample Output
5

题目很长，解释一下题目：在每个城市都有一个物品的买入和卖出的价格（二者是相等的），求从起点到终点的的这条路中找到最大利润（利润=卖出的价格-买入的价格）。

思路

两遍spfa

一开始笔者拿到这道题是没有思路的
对于这道题而言，我们要求的只是最后的最大利润是多少。

1. 我们就可以将这个问题转化成找到从起点到终点的这条路径上的最小的买入价值点和最大的卖出价值点；
2. 问题就是：现在我们并不知道最小的买入价值点和最大的卖出价值点在哪，以及能否从起点到达买入点，能否从买入点到达卖出点，能否从卖出点到达终点。
3. 这里就可以引入DP的思想（笔者不会DP ）。从起点开始遍历，点 i 的最小的买入价值就是前 i 个点的最小的买入价值；同样的，从终点开始往回找，点 j 的最大卖出价值就是 j 到终点之间那么多点的最大卖出价值。【这里是重点】
4. 在找到每个点的最小的买入价值和最大的卖出价值的时候，再将每个点都遍历一遍求出最终的最大利润。

【这里是难点，对于笔者而言】当思路有了之后，就发现十分难以实现！！
要如何正反跑（从0跑到 i ，从 j 跑到 n），这个图要怎么建……（陷入迷茫 ）【当然你也可以直接DP……】
在Tyouchie的帮助下，我就被告知了可以跑两遍spfa，将图正反建。

建图：

	for(int i=1;i<=m;++i)
	{
		int a=read();
		int b=read();
		int z=read();
		add1(a,b);
		add2(b,a);
		if(z==2)
			add1(b,a),add2(a,b);
	}

理解一下思想，正向建图的话就正常建，反向建图的话，就把每个点都反过来，因为反向建图是为了确保你反向建图到达的点 可以在 正向建图 的图中到达终点。[好晕]

代码

#include<bits/stdc++.h>
using namespace std;
const int nn=100010;
const int mm=500010;
int n,m;
int c[nn];
int maxx[nn],minn[nn],vis[nn];

int read()
{
    int x=0,f=1; char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-') f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0'; ch=getchar();}
    return x*f;
}

struct edge
{
    int fr,to,ver,nex;
}e1[2*mm],e2[2*mm];
int last1[nn],last2[nn];
int num1=0,num2=0;

void add1(int x,int y)
{
    e1[++num1].to=y;
    e1[num1].nex=last1[x]; last1[x]=num1;
}

void add2(int x,int y)
{ 
    e2[++num2].to=y;
    e2[num2].nex=last2[x]; last2[x]=num2;
}

void spfa1(int xx)
{
    queue<int> q;
    memset(vis,0,sizeof(vis));
    memset(minn,0x3f3f3f3f,sizeof(minn));
    minn[xx]=c[xx];
    vis[xx]=1;
    q.push(xx);
    while(q.size())
    {
        int x=q.front(); q.pop();
        vis[x]=0;
        for(int i=last1[x];i;i=e1[i].nex)
        {
            int y=e1[i].to;
            if(minn[y]>minn[x])
            {
                minn[y]=min(c[y],minn[x]);
                if(!vis[y])
                    vis[y]=1,q.push(y);
            }
        }
    }
}

void spfa2(int xx)
{
    queue<int> q;
    memset(vis,0,sizeof(vis));
    memset(maxx,0xcf,sizeof(maxx));
    maxx[xx]=c[xx];
    vis[xx]=1;
    q.push(xx);
    while(q.size())
    {
        int x=q.front(); q.pop();
        vis[x]=0;
        for(int i=last2[x];i;i=e2[i].nex)
        {
            int y=e2[i].to;
            if(maxx[y]<maxx[x])
            {
                maxx[y]=max(c[y],maxx[x]);
                if(!vis[y])
                    vis[y]=1,q.push(y);
            }
        }
    }
}

int main()
{
    n=read(); m=read();
    for(int i=1;i<=n;++i)
        c[i]=read();
    for(int i=1;i<=m;++i)
    {
        int a=read();
        int b=read();
        int z=read();
        add1(a,b);
        add2(b,a);
        if(z==2)
            add1(b,a),add2(a,b);
    }
    spfa1(1);spfa2(n);//两遍spfa
    int ans=0;
    for(int i=1;i<=n;++i)
        ans=max(ans,maxx[i]-minn[i]);
    cout<<ans<<endl;
    return 0;
}

其实还会有其他的思路比如说 分层图，dijkstra，tarjan等算法。。。

未完待续……