星际转移问题（最大流，分层图，并查集，网络流24题）

题意

思路

这道题有两个量，一个是人数（作为限制条件），另一个是天数（作为优化目标）。遇到这种问题，一般考虑分层图，将优化目标作为层。

这道题将\(n + 2\)个空间站（包括地球和月球）作为节点，将天数作为层，即每层\(n + 2\)个节点。

位于前一天空间站的人数转移方式有两种，一种是留在这个空间站（向下一天该空间站连一条容量是\(\infty\)的边）；另一种是正好有车经过，转移到下一站的空间站（向下一天的目标空间站连一条容量为公交车承载量的边）。

设置一个虚拟源点\(S\)，向第\(0\)天的\(0\)号点（地球）连一条容量为总人数的边；设置一个虚拟汇点\(T\)，每一天的\(n + 1\)号点（月球）向\(T\)连一条容量为\(\infty\)的边。

枚举天数，直到最大流等于总人数时为止，此时天数为答案。这里遍历枚举比二分更加高效，原因是可以在之前的基础上继续增广，不需要每次都从头开始做。

判断是否有解，就是要考虑地球与月球是否连通，如果不连通则无解。这个可以通过并查集来解决。

代码

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

using namespace std;

const int N = 750 * 15 + 2, M = (750 + 750 * 20 + 750) * 2, inf = 1e8;

int n, m, K, S, T;
int h[N], e[M], ne[M], f[M], idx;
int cur[N], d[N];
int p[30];

struct Ships
{
    int v, s, id[30];
}ships[30];

int find(int x)
{
    if(p[x] != x) p[x] = find(p[x]);
    return p[x];
}

void add(int a, int b, int c)
{
    e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx ++;
    e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx ++;
}

bool bfs()
{
    memset(d, -1, sizeof(d));
    queue<int> que;
    que.push(S);
    d[S] = 0, cur[S] = h[S];
    while(que.size()) {
        int t = que.front();
        que.pop();
        for(int i = h[t]; ~i; i = ne[i]) {
            int ver = e[i];
            if(d[ver] == -1 && f[i]) {
                d[ver] = d[t] + 1;
                cur[ver] = h[ver];
                if(ver == T) return true;
                que.push(ver);
            }
        }
    }
    return false;
}

int find(int u, int limit)
{
    if(u == T) return limit;
    int flow = 0;
    for(int i = cur[u]; ~i && flow < limit; i = ne[i]) {
        cur[u] = i;
        int ver = e[i];
        if(d[ver] == d[u] + 1 && f[i]) {
            int t = find(ver, min(f[i], limit - flow));
            if(!t) d[ver] = -1;
            f[i] -= t, f[i ^ 1] += t, flow += t;
        }
    }
    return flow;
}

int dinic()
{
    int res = 0, flow;
    while(bfs()) {
        while(flow = find(S, inf)) {
            res += flow;
        }
    }
    return res;
}

int get(int id, int day)
{
    return day * (n + 2) + id;
}

int main()
{
    scanf("%d%d%d", &n, &m, &K);
    memset(h, -1, sizeof(h));
    S = N - 2, T = N - 1;
    for(int i = 0; i <= n + 1; i ++) p[i] = i;
    for(int i = 0; i < m; i ++) {
        int v, s;
        scanf("%d%d", &v, &s);
        ships[i] = {v, s};
        for(int j = 0; j < s; j ++) {
            int id;
            scanf("%d", &id);
            if(id == -1) id = n + 1;
            ships[i].id[j] = id;
            if(j) {
                int tmp = find(ships[i].id[j - 1]);
                p[find(id)] = tmp;
            }
        }
    }
    if(find(0) != find(n + 1)) puts("0");
    else {
        int res = 0;
        add(S, get(0, 0), K);
        add(get(n + 1, 0), T, inf);
        int day = 1;
        while(true) {
            add(get(n + 1, day), T, inf);
            for(int i = 0; i <= n + 1; i ++) {
                add(get(i, day - 1), get(i, day), inf);
            }
            for(int i = 0; i < m; i ++) {
                int s = ships[i].s, v = ships[i].v;
                int a = ships[i].id[(day - 1) % s], b = ships[i].id[day % s];
                add(get(a, day - 1), get(b, day), v);
            }
            res += dinic();
            if(res >= K) break;
            day ++;
        }
        printf("%d\n", day);
    }
    return 0;
}