10月27日備戰Noip2018模擬賽11（B組）

T3 Monogatari物語

題目描述

某一天，少年邂逅了一見鍾情的IA。見面後，IA一把牽起少年的手，決定和他一起逃離部落，離開這個無法容身的是非之地。

    要逃離部落，少年和IA就需要先選擇一條耗時最少的路線，從而避免被部落的大人們抓到。部落可以大致分為Ñ個區域，少年和IA在區域1中，部落的出口設在區域N.此外部落還有中號條連線兩個區域道路。道路是無向的，沒有一條道路的兩端連線相同的區域，也沒有兩條道路所連線的兩個區域完全相同。對於其中前（M -1）條道路，其通過時間是確定的，但最後一條道路，由於地理因素，通過其的時間會不斷變化。

現在，少年和IA得知了在K個不同的時段裡，通過第M條道路的時間，請您分別計算出在這K個時段中逃離部落的最少時間，以幫助他們確定行動的時刻

輸入格式

第一行三個整數N，M，K，分別表示區域數，道路數，詢問數。

    接下來的M-1行每行三個整數UI，VI，WI（UI≠VI，1≤ui，vi≤N，0 <wi≤10^ 9），表示這條道路連線的區域和通過時間。

    緊接著是兩個整數的ui，六（UI≠VI，1≤ui，vi≤N），表示第中號條道路連線的區域。

    最後ķ行，每行一個正整數XI（0 <xi≤10^ 9），表示目前第中號條道路的通過時間。

輸出格式

輸出共計ķ行，每行一個整數，表示對應時段逃離部落的最短時間。如果在該時段內無法逃離，輸出“+ Inf檔案”。

輸入樣例

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

輸出樣例

8
9
10
10

樣例解釋

如圖1，紅色的圓圈表示少年和IA的出發地，綠色的圓圈表示目的地，連線表示道路，旁邊的數字表示通過該道路的時間。最後一條道路時間未知用X表示。

圖中不重複經過同一區域的路徑有4條，分別為1→2→4,1→3→4,1→2→3→4,1→3→2→4，其所需時間隨X的關係如下表所示

可以證明，不存在更優的解，故將上表最後一列輸出。

資料範圍

思路

這個資料範圍猛一看真的很噁心啊

（1）對於每一次變化，我們都可以用SPFA來求出1 - n的最短路，那這樣的複雜度就是，也是會tle的

（2）那麼可以把（1）的方法稍微改進一下，用樣例的情況舉例，只要用兩次SPFA，

1. 將最後一條通過時間不確定的道路當做不連通
2. 第一次SPFA求出1到其他點的最短路用dis1 []表示
3. 第二次SPFA求出4到其他點的最短路用dis2 []表示
4. 最短路= min（dis1 [2] + x + dis2 [3]，dis2 [2] + x + dis1 [3]，dis1 [4]）

這樣子的複雜度就變成了

程式碼

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>

using namespace std;

const int MAXN = 2e5 + 5; 
const int MAXM = 5e5 + 5; 
const long long INF = 0x7fffffffffffffffll / 3; 

struct Data{
	long long x;
	int y;
	bool operator < (const Data &a) const
	{
		return a.x < x;
	}
};

struct Node{
	int frm, nxt, to, dst;
}a[MAXM * 2];

priority_queue <Data> Q;

int n, m, k, U, V, numEdge;
int vis[MAXN], head[MAXN];
long long dis1[MAXN], dis2[MAXN];

inline int read ();
inline void addEdge (int u, int v, int w);
inline void SPFA (int start);

int main ()
{
	freopen("monogatari.in", "r", stdin); 
	freopen("monogatari.out", "w", stdout); 
	
	int u, v, w;
	n = read (), m = read (), k = read ();
	for (int i = 1; i < m ; ++ i){
		u = read (), v = read (), w = read ();
		addEdge (u, v, w);
		addEdge (v, u, w);
	}
	U = read (), V = read ();
	
	SPFA (1);
	memcpy (dis1, dis2, sizeof (dis1));            //儲存前一次求出的最短路
	SPFA (n);
	
	for (int i = 1; i <= k; ++ i){
		int d = read ();
		long long ans = min (dis1[n], min (dis1[U] + d + dis2[V], dis2[U] + d + dis1[V]));
		if (ans >= INF) printf ("+Inf\n");
		else printf ("%lld\n", ans);
	}
	
	fclose (stdin);
	fclose (stdout);
	return 0;
}

inline int read ()
{
	char ch = getchar ();
	int f = 1;
	while (!isdigit (ch)) {
		if (ch == '-') f = -1;
		ch = getchar ();
	}
	int x = 0;
	while (isdigit (ch)) {
		x = x * 10 + ch - '0';
		ch = getchar ();
	}
	return x * f;
}

inline void addEdge (int u, int v, int w)
{
	++ numEdge;
	a[numEdge].dst = w;
	a[numEdge].to = v;
	a[numEdge].nxt = head[u];
	head[u] = numEdge;
	return ;
}

inline void SPFA (int start)
{
	fill (dis2, dis2 + MAXN, INF);
	Data tmp;
	tmp.x = 0;
	tmp.y = start;
	Q.push (tmp);
	vis[start] = true;
	dis2[start] = 0;
	do{
		int u = Q.top ().y;
		int t = Q.top ().x;
		Q.pop ();
		if (t > dis2[u]) continue;
		for (int i = head [u]; i; i = a[i].nxt){
			int v = a[i].to;
			if (dis2[v] > dis2[u] + a[i].dst){
				dis2[v] = dis2[u] + a[i].dst;
				tmp.x = dis2[v];
				tmp.y = v;
				Q.push (tmp);
			}
		}
	}while (!Q.empty ());
}