洛谷P2754 家园（分层图+最大流）网络流24题（1）

洛谷P2754 家园（分层图+最大流）

链接
题意：有$m$个太空船和$n$个太空站，$m$艘太空船会周期性的停靠在一些太空站上，每过一个时间走一步，也可以选择不走，每艘太空船可以容纳一定数量的人，但是每艘船容纳的人不一样，太空站可以容纳无限多的人，一开始所有$k$个人都在地球，现在要把这些人都转移到月球，问需要多少时间。
思路：首先可以先判一下连通性，然后开始建图，因为很麻烦的周期性，并且每个飞船在一定时间剩下的容纳人数不一定，所以很难直接跑出来，但是关键是时间，假设在某个时间，整个图的最大流大于k了，那就说明这个时间就是答案，所以我们可以试着枚举时间，根据时间来建立分层图，首先容易想到的是，对于每个点，在每个时间它一定会和上个时间的它连接一条容量为无限大的边，代表这个飞船停靠在这个点，没有动，然后考虑飞船飞的情况，因为是枚举的时间，对于每个时间，枚举所有的飞船，看正常走，这个飞船会走到哪个地方，因为我们有专门连接停靠的边，所以就不需要考虑其他的了，停靠的再走的情况会从停靠中转移，所以分层图大概就建立出来了，对于每次时间都重新添加一些图建新图，然后不断跑残量网络，当某个时候最大流大于k了，就输出这个时间，结束算法。技术力有限，就不画图了。

#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef long long ll;
const int INF = 2147483647000000;
const int N = 1e6+10;
int head[N], idx = 1;
struct Edge{int to, nxt, d;}e[N << 1];
void add(int u, int v, int d)
{
    e[++idx].to = v, e[idx].nxt = head[u], e[idx].d = d, head[u] = idx;
    e[++idx].to = u, e[idx].nxt = head[v], e[idx].d = 0, head[v] = idx;
}
int fa[150];
int find(int n) {return n == fa[n] ? n : fa[n] = find(fa[n]);}
int p[150], num[150], g[150][150];
int ans;
ll dep[N], gap[N], cur[N];
ll n, m, s, t, k;
ll maxflow;

void bfs()
{
    memset(dep, -1, sizeof (dep));
    dep[t] = 0;
    gap[0] = 1;
    queue<ll> Q;
    Q.push(t);
    while (!Q.empty()) {
        ll u = Q.front(); Q.pop();
        for (ll i = head[u]; i; i = e[i].nxt) {
            ll v = e[i].to;
            if (dep[v] != -1) continue;
            dep[v] = dep[u] + 1;
            gap[dep[v]]++;
            Q.push(v);
        }
    }
}

ll dfs(ll u, ll flow)
{
    if (u == t) {
        maxflow += flow;
        return flow;
    }
    ll used = 0;
    for (ll &i = cur[u]; i; i = e[i].nxt) {
        ll v = e[i].to, d = e[i].d;
        if (d && dep[v] + 1 == dep[u]) {
            ll mi = dfs(v, min(flow - used, d));
            if(mi) {
                e[i].d -= mi;
                e[i ^ 1].d += mi;
                used += mi;
            }
            if (used == flow) return used;
        }
    }
    gap[dep[u]]--;
    if (gap[dep[u]] == 0) dep[s] = N + 1;
    dep[u]++;
    gap[dep[u]]++;
    return used;
}

void ISAP()
{
    bfs();
    while (dep[s] < N) {memcpy(cur, head, sizeof (head));dfs(s, INF);}
}

signed main()
{
    cin >> n >> m >> k;
    for (int i = 1; i <= n + 2; i++) {fa[i] = i;}
    for (int i = 1; i <= m; i++) {
        cin >> p[i] >> num[i];
        for (int j = 0; j < num[i]; j++) {
            cin >> g[i][j];
            if (g[i][j] == 0) g[i][j] = n + 1;
            if (g[i][j] == -1) g[i][j] = n + 2;
            if (j) {
                int x = g[i][j], y = g[i][j - 1];
                x = find(x), y = find(y);
                if (x == y) continue;
                fa[x] = y;
            }
        }
    }
    t = N - 3;
    if (find(n + 2) != find(n + 1)) {cout << 0 << endl; return 0;}
    for (ans = 1;; ans ++) {
        add(s, (ans - 1) * (n + 1) + n + 1, INF);
        for (int i = 1; i <= m; i++) {
            int x = (ans - 1) % num[i], y = ans % num[i];
            if (g[i][x] == n + 2) x = t;
            else x = (ans - 1) * (n + 1) + g[i][x];
            if (g[i][y] == n + 2) y = t;
            else y = ans * (n + 1) + g[i][y];
            add(x, y, p[i]);
        }
        ISAP();
        if (maxflow >= k) {cout << ans << endl; return 0;}
        for (int i = 1; i <= n + 1; i++) {add((ans - 1) * (n + 1) + i, ans * (n + 1) + i, INF);}
    }
    return 0;
}