「NOIP2009」最优贸易题解

题目描述

$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$之间的双向道路。

输出格式

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

输入输出样例

输入

输出

说明/提示

【数据范围】

输入数据保证$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$。

NOIP 2009 提高组第三题

思路（Tarjan缩点+拓扑排序+DP）

首先来考虑如果该图为DAG的情况（每个点所在集合为自己）。

（maxn[i] 表示在i点时最大卖出价格，minn[i] 表示在i点时最小进价）

可以借用拓扑排序进行DP实行状态转移，找到1号点能到达的点的答案。在拓扑排序中，有两点u，v满足，有一条边u到v，如果u被访问过（即是已经求出到达该点的最优解），则将v置为已访问（先将1所在集合记为访问过），进行对于u到v的状态转移。

更新在v点买进的最小进价：

minn[v]=min(minn[v],minn[u])

更新在走到v点时的最优解：

dp[v]=max(dp[u],dp[v],maxn[v]-minn[v])

最后拓扑排序结束之后，答案就存在dp[belong[i]]中了。

但是，题目中说了会有环

所以，先对该图进行Tarjan缩点，对于旧图建一张新图，将其变为DAG。

我们需要初始化：

maxn[i]为所有属于i集合的点的价值最大值

minn[i]为所有属于i集合的点的价值最小值

然后进行上述DAG中的操作即可。

C++代码：

#include <queue>

#include <stack>

#include <cstdio>

#include <vector>

#include <cstring>

#include <algorithm>

using namespace std;

const int MAXN = 1e5 + 5;

vector<int> v[MAXN], Dag[MAXN];

stack<int> s;

queue<int> q;

int dfn[MAXN], low[MAXN], belong[MAXN], elem[MAXN];

bool instack[MAXN], vis[MAXN];

int tim, cnt_set;

int w[MAXN], maxn[MAXN], minn[MAXN], in[MAXN], dp[MAXN];

int n, m, ans;

void Read();

void Tarjan(int);

void Build();

void Topo();

int main() {

	Read();

	Build();

	Topo();

	return 0;

}

void Topo() {

	vis[belong[1]] = 1;

	for(int i = 1; i <= cnt_set; i++)

		if(!in[i])

			q.push(i);

	while(!q.empty()) {

		int now = q.front(); q.pop();

		int SIZ = Dag[now].size();

		for(int i = 0; i < SIZ; i++) {

			int next = Dag[now][i];

			if(vis[now]) {

				vis[next] = 1;

				minn[next] = min(minn[next], minn[now]);

				dp[next] = max(dp[now], max(dp[next], maxn[next] - minn[next]));

			}

			if(!(--in[next]))

				q.push(next);

		}

	}

	printf("%d", dp[belong[n]]);

}

void Build() {

	for(int i = 1; i <= n; i++)

		if(!dfn[i])

			Tarjan(i);

	memset(minn, 0x7f, sizeof(minn));

	for(int i = 1; i <= n; i++) {

		maxn[belong[i]] = max(maxn[belong[i]], w[i]);

		minn[belong[i]] = min(minn[belong[i]], w[i]);

	}

	for(int i = 1; i <= n; i++) {

		int SIZ = v[i].size();

		for(int j = 0; j < SIZ; j++) {

			int next = v[i][j];

			if(belong[i] != belong[next]) {

				Dag[belong[i]].push_back(belong[next]);

				in[belong[next]]++;

			}

		}

	}

}

void Tarjan(int now) {

	low[now] = dfn[now] = ++tim;

	instack[now] = true;

	s.push(now);

	int SIZ = v[now].size();

	for(int i = 0; i < SIZ; i++) {

		int next = v[now][i];

		if(!dfn[next]) {

			Tarjan(next);

			low[now] = min(low[now], low[next]);

		}

		else if(instack[next])

			low[now] = min(low[now], dfn[next]);

	}

	if(dfn[now] == low[now]) {

		cnt_set += 1;

		int Top = -1;

		while(!s.empty() && Top != now) {

			elem[cnt_set]++;

			Top = s.top();

			belong[Top] = cnt_set;

			instack[Top] = false;

			s.pop();

		}

	}

}

void Read() {

	scanf("%d %d", &n, &m);

	for(int i = 1; i <= n; i++)

		scanf("%d", &w[i]);

	for(int i = 1; i <= m; i++) {

		int U, V, F;

		scanf("%d %d %d", &U, &V, &F);

		if(F == 1)

			v[U].push_back(V);

		else {

			v[U].push_back(V);

			v[V].push_back(U);

		}

	}

}

该方法的时间复杂度就是$O(n+m)$。

因为$m>n$，时间复杂度就可以算作$O(m)$