傳送


題面：有\(n\)個星球，用最短時間把\(k\)個超級計算機從星球\(S\)運送到\(T\)。每個計算機需要一整艘飛船來運。行星間有\(m\)條雙向隧道，每條隧道需要一天通過，且不能有兩艘飛船同時使用同一條隧道。隧道不會連線兩個相同的行星，每對行星之間最多隻有一條隧道。隧道是雙向的，但每一天只有一艘飛船能穿過一條。兩艘飛船不能同時沿著相反方向穿過同一隧道。


這破題終極無敵折磨人，我抄程式碼都超了半天。

首先他問最多多少天嘛，那可以先想想二分。

對於當前二分天數\(d\)，我們將每個點\(i\)拆成\(d+1\)個，分別表示第\(0,1,\cdots,d\)天的點\(i\)。然後連邊就對應的是兩種操作：

1. 如果原圖\(u\to v\)，那麼將連邊\(u_{j}\to v_{j+1}\)，容量為\(1\)，表示第\(j\)天在\(u\)節點的東西可以在第\(j+1\)天移動到節點\(v\).
2. 連邊\(u_j \to u_{j+1}\)，容量為無窮，表示這個點的東西我可以一直放著。

然後跑最大流，看是否等於等於總物體數\(k\)即可。

但上述都不是這道題的關鍵點，關鍵點是以下兩點：

一、如果每次二分重新建圖，重新跑Dinic，會很慢（不知道能不能過）。改成隨天數增加，在上一天的基礎上動態建圖跑Dinic，效率會提升不少。

二、終極無敵折磨人之輸出路徑。好好的題，就被輸出路徑給毀了。看了陳老師的題解才知道怎麼輸出路徑：

我們一天天來，看每一個節點上是否有流，如果\(flow(u_j \to v_{j+1})=1\)且\(flow(v_j \to u_{j+1})=0\)，才表示有個物體在第\(j\)天從\(u\)運到了\(v\)（第二個條件是為了保證不再運回來）。

記錄下來每一天物體的動向，只要將這些動向分配個物體就行了。注意的是，我們並不關注是哪個物體移動了，只要這個物體符合在第\(d\)天在\(u\)，且當天沒移動過，就可以將他移動到\(v\).

這道題完整思路基本就是這些，程式碼感覺還是挺難寫的。尤其是老師的程式碼判斷是否有流量那部分，通過動態維護一個變數來表示那條邊的編號，感覺不好理解，自己的程式碼裡就改成了在建圖的時候記錄邊的編號了。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<queue>
#include<assert.h>
#include<ctime>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
#define forE(i, x, y) for(int i = head[x], y; ~i && (y = e[i].to); i = e[i].nxt)
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxm = 205;
const int maxn = 1e4 + 5;
const int maxe = 2e6 + 5;
In ll read()
{
	ll ans = 0;
	char ch = getchar(), las = ' ';
	while(!isdigit(ch)) las = ch, ch = getchar();
	while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
	if(las == '-') ans = -ans;
	return ans;
}
In void write(ll x)
{
	if(x < 0) x = -x, putchar('-');
	if(x >= 10) write(x / 10);
	putchar(x % 10 + '0');
}

int n, m, K, s, t, _t;
int u[maxm], v[maxm];
struct Edge
{
	int nxt, to, cap, flow;
};
vector<Edge> e;	 //因為懶得計算總邊數，把鏈前魔改了一下，四不像了哈 
int head[maxn], ecnt = -1;
In void addEdge(int x, int y, int w)
{
	e.push_back((Edge){head[x], y, w, 0});
	head[x] = ++ecnt;
	e.push_back((Edge){head[y], x, 0, 0});
	head[y] = ++ecnt;
}

int dis[maxn];
In bool bfs()
{
	Mem(dis, 0), dis[s] = 1;
	queue<int> q; q.push(s);
	while(!q.empty())
	{
		int now = q.front(); q.pop();
		for(int i = head[now], v; ~i; i = e[i].nxt)
			if(e[i].cap > e[i].flow && !dis[v = e[i].to])
				dis[v] = dis[now] + 1, q.push(v);
	}
	return dis[t];
}
int cur[maxn];
In int dfs(int now, int res)
{
	if(now == t || res == 0) return res;
	int flow = 0, f;
	for(int& i = cur[now], v; ~i; i = e[i].nxt)
	{
		if(dis[v = e[i].to] == dis[now] + 1 && (f = dfs(v, min(res, e[i].cap - e[i].flow))) > 0)
		{
			e[i].flow += f, e[i ^ 1].flow -= f;
			flow += f, res -= f;
			if(res == 0) break;
		}
	}
	return flow;
}
In int maxFlow(int lim)
{
	int flow = 0;
	while(bfs())
	{
		memcpy(cur, head, sizeof(head));
		flow += dfs(s, lim - flow);
		//就這，按原來的寫法寫dfs(s, INF)就錯！不知道為什麼 
		if(flow >= lim) break;
	}
	return flow;
}


In int ID(int x, int d) {return d * n + x;}
int pos[maxn], idE[maxm][maxm];
bool moved[maxn];

int main()
{
	Mem(head, -1), ecnt = -1;
	n = read(), m = read(), K = read(), s = read(), _t = read();
	for(int i = 1; i <= m; ++i) u[i] = read(), v[i] = read();
	int day = 1, flow = 0;
	while(1)
	{
		for(int i = 1; i <= n; ++i) addEdge(ID(i, day - 1), ID(i, day), INF);
		for(int i = 1; i <= m; ++i)
		{
			idE[i][day] = ecnt + 1;
			addEdge(ID(u[i], day - 1), ID(v[i], day), 1);
			addEdge(ID(v[i], day - 1), ID(u[i], day), 1);
		}
		t = ID(_t, day);
		flow += maxFlow(K - flow);
		if(flow >= K) break;
		day++;
	}
	write(day), enter;
	fill(pos + 1, pos + K + 1, s);				//pos[i]表示物體i當前移到了哪個點  
	for(int d = 1; d <= day; ++d)
	{
		fill(moved + 1, moved + K + 1, 0);
		vector<int> a, b;
		for(int i = 1; i <= m; ++i)
		{
			int f1 = e[idE[i][d]].flow;			//是否是從u_d到v_{d+1} 
			int f2 = e[idE[i][d] + 2].flow;		//是否是從v_d到u_{d+1}
			if(f1 == 1 && !f2) a.push_back(u[i]), b.push_back(v[i]);
			if(!f1 && f2 == 1) a.push_back(v[i]), b.push_back(u[i]); 
		}
		write(a.size());
		for(int i = 0; i < (int)a.size(); ++i)
			for(int j = 1; j <= K; ++j)
				if(!moved[j] && pos[j] == a[i])	//符合條件就移動，無論哪個物體 
				{
					space, write(j), space, write(b[i]);
					moved[j] = 1, pos[j] = b[i];
					break;
				}
		enter;
	}
	return 0;
}