传送
题面：有(n)个星球，用最短时间把(k)个超级计算机从星球(S)运送到(T)。每个计算机需要一整艘飞船来运。行星间有(m)条双向隧道，每条隧道需要一天通过，且不能有两艘飞船同时使用同一条隧道。隧道不会连接两个相同的行星，每对行星之间最多只有一条隧道。隧道是双向的，但每一天只有一艘飞船能穿过一条。两艘飞船不能同时沿着相反方向穿过同一隧道。
这破题终极无敌折磨人，我抄代码都超了半天。
首先他问最多多少天嘛，那可以先想想二分。
对于当前二分天数(d)，我们将每个点(i)拆成(d+1)个，分别表示第(0,1,cdots,d)天的点(i)。然后连边就对应的是两种操作：
- 如果原图(u o v)，那么将连边(u_{j} o v_{j+1})，容量为(1)，表示第(j)天在(u)节点的东西可以在第(j+1)天移动到节点(v).
- 连边(u_j o u_{j+1})，容量为无穷，表示这个点的东西我可以一直放着。
然后跑最大流，看是否等于等于总物体数(k)即可。
但上述都不是这道题的关键点，关键点是以下两点：
一、如果每次二分重新建图，重新跑Dinic，会很慢（不知道能不能过）。改成随天数增加，在上一天的基础上动态建图跑Dinic，效率会提升不少。
二、终极无敌折磨人之输出路径。好好的题，就被输出路径给毁了。看了陈老师的题解才知道怎么输出路径：
我们一天天来，看每一个节点上是否有流，如果(flow(u_j o v_{j+1})=1)且(flow(v_j o 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;
}