算法进阶指南图论 最优贸易

最优贸易

题目描述

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

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

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

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

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

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

阿龙也可以选择如下一条线路：$1\to 4\to 5\to 4\to 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$ 之间的双向道路。

输出格式

一个整数，表示最多能赚取的旅费。如果没有进行贸易，则输出 $0$。

样例 #1

样例输入 #1

5 5 
4 3 5 6 1 
1 2 1 
1 4 1 
2 3 2 
3 5 1 
4 5 2
1
2
3
4
5
6
7

样例输出 #1

5
1

提示

【数据范围】

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

对于 $10\%$ 的数据，$1\le n\le 6$。

对于 $30\%$ 的数据，$1\le n\le 100$。

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

对于 $100\%$ 的数据，$1\le n\le 100000$，$1\le m\le 500000$，$1\le x,y\le n$，$1\le z\le 2$，$1\leq $ 各城市的编号 $\le n$。

水晶球价格 $\le 100$。

思路一：

考虑分层图，因为每个点有两种状态，为买入和卖出，所以我们可以建三层图，平行层之间的边权为0，从第一层到 第二层由当前点$u$向$u+n$连一条边，表示买入，边权为$-w$，同理，我们由$u+n$向$u+n\ast 2$连一条价值为$w$的边，表示卖出。然后对整个图去跑最长路即可(因为题目说要价值最大）

#include 

using namespace std;
const int N = 1e5 + 5;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef array<ll, 3> p3;
int mod = 1e9+7;
const int maxv = 4e6 + 5;
// #define endl "\n"

int n,m;

vector<pll> e[N];

void add(int u,int v,int w)
{
	e[u].push_back({v,w});
}

int st[N];
int d[N];
void spfa()
{
    memset(d,0x3f,sizeof(d));
    d[1]=0;
    queue<int> q;
    q.push(1);
    st[1]=1;
    while(!q.empty()){
        int t=q.front();
        q.pop();
        st[t]=0;
        int i;
        for(auto v:e[t]){
            int b=v.first;
            int w=v.second;
            if(d[b]>d[t]+w){
                d[b]=d[t]+w;
                if(!st[b]){
                q.push(b);
                st[b]=1;
                }
            }
        }
    }
}

void solve()
{
	cin>>n>>m;
	vector<int> a(n+5);
	for(int i=1;i<=n;i++) cin>>a[i],add(i,i+n,-a[i]),add(i+n,i+2*n,a[i]);
	for(int i=1;i<=m;i++){
		int x,y,z;
		cin>>x>>y>>z;
		add(x,y,0);
		add(x+n,y+n,0);
		add(x+n*2,y+n*2,0);
		if(z==2){
			add(y,x,0);
			add(y+n,x+n,0);
			add(y+n*2,x+n*2,0);
		}
	}
	spfa();
	cout<<d[n]<<endl;
}

int main()
{
    ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int t;
	t=1;
	//cin>>t;
	while(t--){
		solve();
	}
   	system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

思路二：

强连通分量缩点然后进行dp。
初始想法，我们考虑若其为DAG,那么我们可以直接进行DP，但又因为肯定存在环，所以可以对其进行强连通分量缩点。

因为缩完点后为DAG，即有向无环图，而我们对于有向无环图可以直接进行dp，同时我们还可以知道每个强连通分量的最小价值和最大价值，那么我们用dp处理出从 1 号点开始，能到达所有点的最小买入价值，然后用该点的卖出价值减去买入价值，最后对其取max即可。

#include 

using namespace std;
const int N = 1e5 + 5;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef array<ll, 3> p3;
int mod = 1e9+7;
// const int maxv = 4e6 + 5;
// #define endl "\n"
int n, m, tot, dfsn[N], ins[N], low[N];
stack<int> s;
vector<int> e[N], e2[N],e3[N];//分别用来存初始图，缩点后的图，缩点后的图对应的反图
vector<vector<int>> scc;
vector<int> b(N);
int a[N];
int minv[N],maxv[N];

struct node
{
	int u,v,z;
}h[N];


void dfs(int x)
{
	low[x] = dfsn[x] = ++tot, ins[x] = 1, s.push(x);
	for (auto u : e[x])
	{
		if (!dfsn[u])
		{
			dfs(u);
			low[x] = min(low[x], low[u]);
		}
		else if (ins[u])
			low[x] = min(low[x], dfsn[u]);
	}
	if (dfsn[x] == low[x])
	{
		vector<int> c;
		while (1)
		{
			auto t = s.top();
			c.push_back(t);
			ins[t] = 0;
			s.pop();
			b[t] = scc.size();
			int sz=scc.size();
			minv[sz]=min(minv[sz],a[t]);
			maxv[sz]=max(maxv[sz],a[t]);
			if (t == x)
				break;
		}
		scc.push_back(c);
	}
}

void add(int u, int v)
{
	e[u].push_back(v);
}

bool vis[N];

void dfs2(int x)
{
	vis[x]=1;
	for(auto u: e3[x])
		if(!vis[u]) dfs2(u);
}

void solve()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++) cin>>a[i];
	for(int i=1;i<=m;i++){
		int u,v,z;
		cin>>u>>v>>z;
		h[i]={u,v,z};
		add(u,v);
		if(z==2) add(v,u);
	}
	memset(minv,0x3f,sizeof minv);
	for(int i=1;i<=n;i++){
		if(!dfsn[i]){
			dfs(i);
		}
	}
	//缩点过程
	for(int i=1;i<=m;i++){
		auto [u,v,z]=h[i];
		int x=b[u],y=b[v];
		if(x!=y) {
			e2[x].push_back(y),e3[y].push_back(x);
			if(z==2) e2[y].push_back(x),e3[x].push_back(y);//同时注意因为题目中说存在双向边，所以在缩点后的建图中同样也需要建立
		}
	}
	vector<int> dp(n+5);
	for(int i=0;i<scc.size();i++) dp[i]=minv[i];
	int st=b[1];
	int ed=b[n];
	dfs2(ed);//因为要确保能到达n点，所以从n开始进行dfs搜索能够到达的点，由此需要缩点后的反图
	int ans=0;
	for(int i=st;i>=0;i--){//从1号点开始，强连通分量即为逆拓扑序
		if(vis[i]) {
			ans=max(ans,maxv[i]-dp[i]);
		}
		for(auto u: e2[i]){
			dp[u]=min(dp[u],dp[i]);
		}
	}
	cout<<ans<<endl;
}

int main()
{
    ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int t;
	t=1;
	//cin>>t;
	while(t--){
		solve();
	}
   	system("pause");
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129