技術標籤：圖論

【SSL】1889 &【洛谷】P1073最優貿易

題目描述

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 行，每行有33個正整數x,y,z，每兩個整數之間用一個空格隔開。如果 z=1，表示這條道路是城市x到城市y之間的單向道路；如果z=2，表示這條道路為城市 x和城市y之間的雙向道路。

輸出格式

一 個整數，表示最多能賺取的旅費。如果沒有進行貿易，則輸出 0。

輸入輸出樣例

輸入

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

輸出

5
 

說明/提示

【資料範圍】

輸入資料保證 11 號城市可以到達nn號城市。

對於 10%的資料，1≤n≤61≤n≤6。

對於 30%的資料，1≤n≤1001≤n≤100。

對於 50%的資料，不存在一條旅遊路線，可以從一個城市出發，再回到這個城市。

對於 100%的資料，1≤n≤1000001≤n≤100000，1≤m≤5000001≤m≤500000，1≤x1≤x，y≤ny≤n，1≤z≤21≤z≤2，1≤1≤各城市

水晶球價格≤100≤100。

NOIP 2009 提高組 第三題

思路

程式碼

分為3種情況：
1：買前
2：買後賣前
3：賣後

1：買前第i個點表示為i
2：買後賣前第i個點表示為i+n
3：賣後第i個點表示為i+n+n
建邊
每種情況內部建邊
跨情況建邊<i,i+n>=-price[i],<i+n,i+n+n>=price[i],1<=i<=n;
再用SPFA。

SPFA是Bellman-Ford演算法的一種佇列實現，減少了不必要的冗餘計算。
主要思想是：
初始時將起點加入佇列。每次從佇列中取出一個元素，並對所有與它相鄰的點進行修改，若某個相鄰的點修改成功，則將其入隊。直到佇列為空時演算法結束。
這個演算法，簡單的說就是佇列優化的bellman-ford，利用了每個點不會更新次數太多的特點發明的此演算法。
SPFA 在形式上和廣度優先搜尋非常類似，不同的是廣度優先搜尋中一個點出了佇列就不可能重新進入佇列，但是SPFA中一個點可能在出佇列之後再次被放入佇列，也就是說一個點修改過其它的點之後，過了一段時間可能會獲得更短的路徑，於是再次用來修改其它的點，這樣反覆進行下去。
演算法時間複雜度：O(kE)，E是邊數。K是常數，平均值為2。

注意到Bellman-Ford演算法實際上做了很多無用功。因為每次它都把所有的邊列舉一次，而有一些邊在上一次列舉中，起始端頂點都沒有更新，那麼在這一次列舉中，肯定不會進行鬆弛。那麼我們可以使用一個佇列來進行活躍點的維護。我們定義在這個佇列裡的每個元素x都必須滿足：d[x]被更新，但是未利用d[x]去更新其它的點。那麼初始時把起始點1放進佇列裡面，然後對它進行鬆弛操作，並把d值被更新的點放入佇列之中，最後把當前這個做完鬆弛操作的點出隊。重複這個操作直到佇列中沒有元素，那麼所有點的d值都被確定了。
這個演算法同樣可用於有負權邊的情況之中。此外，該演算法也可以用來判斷負權環，具體方法就是如果某一個點入隊超過n次,那麼判斷有負權環。
時間複雜度O(kE),其中k為一個小常數，大致在[3,5]這個範圍內。

演算法實現：
dis[i]記錄從起點s到i的最短路徑，w[i][j]記錄連線i，j的邊的長度。pre[v]記錄前趨。
team[1…n]為佇列，頭指標head，尾指標tail。
布林陣列exist[1…n]記錄一個點是否現在存在在佇列中。
初始化：dis[s]=0,dis[v]=∞（v≠s），memset(exist,false,sizeof(exist));
起點入隊team[1]=s; head=0; tail=1;exist[s]=true;
do
{
1、頭指標向下移一位，取出指向的點u。
2、exist[u]=false;已被取出了佇列
3、for與u相連的所有點v //注意不要去列舉所有點，用陣列模擬鄰接表儲存
if (dis[v]>dis[u]+w[u][v])
{
dis[v]=dis[u]+w[u][v];
pre[v]=u;
if (!exist[v]) //佇列中不存在v點，v入隊。
{
//尾指標下移一位，v入隊;
exist[v]=true;
}
｝
}
while (head < tail);
迴圈佇列：
　　採用迴圈佇列能夠降低佇列大小，佇列長度只需開到2*n+5即可。例題中的參考程式使用了迴圈佇列。

程式碼

#include<iostream>
#include<cstdio>
#include<cstring> 
#include<queue>
using namespace std;
bool d[300010];
int n,m,dis[300010],head[300010],tot=0,a[300010];
struct jgt
{
	int x,y,nxt,s;
}f[5000001];
queue<int> q;
void add(int x,int y)//建邊 
{
	f[++tot].x=x;
	f[tot].y=y;
	f[tot].s=0;
	f[tot].nxt=head[x];
	head[x]=tot;
	return;
}
void input()
{
	int i,x,y,z;
	scanf("%d%d",&n,&m);
	for(i=1;i<=n;i++)
		scanf("%d",&a[i]);
	for(i=1;i<=m;i++)
	{
		scanf("%d%d%d",&x,&y,&z);
		add(x,y);
		add(x+n,y+n);
		add(x+n+n,y+n+n);
		if(z==2)
		{
			add(y,x);
			add(y+n,x+n);
			add(y+n+n,x+n+n);
		}
	}
	for(i=1;i<=n;i++)
	{
		f[++tot].x=i;
		f[tot].y=i+n;
		f[tot].s=-a[i];
		f[tot].nxt=head[i];
		head[i]=tot;
		
		f[++tot].x=i+n;
		f[tot].y=i+n+n;
		f[tot].s=a[i];
		f[tot].nxt=head[i+n];
		head[i+n]=tot;
	}
	return;
}
void SPFA()
{
	int l,r,i;
	memset(d,0,sizeof(d));
	memset(dis,-0x7f7f,sizeof(dis));
	dis[1]=0;
	for(q.push(1),d[1]=1;!q.empty();q.pop())//佇列優化 
	{
		for(i=head[q.front()];i;i=f[i].nxt)
			if(dis[f[i].y]<dis[q.front()]+f[i].s)//鬆弛 
			{
				dis[f[i].y]=dis[q.front()]+f[i].s;
				if(!d[f[i].y])
				{
					q.push(f[i].y);//加入佇列 
					d[f[i].y]=1;
				}
			}
		d[q.front()]=0;//退出佇列 
	}
	return;
}
int main()
{
	input();
	SPFA();
	printf("%d",dis[3*n]);
	return 0;
}