P1073 最优贸易 SPFA or tarjan + 拓扑 + dp
littlechai
2018-05-13 20:45:03
## # **题目描述**##
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])
###### 代码
```cpp
#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即可
##### 代码
```cpp
#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;
}
```