G - Maximize Distance【ABC397】

G - Maximize Distance

思路：

看题目感觉像是网络流。
显然答案具有单调性，可以二分答案判断：

先考虑如果d=1，那么显然答案等于找最小割，也就是最大流。
现在考虑d>1时，我们建d层图，对于原图中的边：$u_d->v_d$ 以及相邻层 $u_d->v_{d+1}$，容量分别为1和 $\infty$ ，源点连接第一层的s，汇点连接每一层的t，找到的最小割即为d对应的答案。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define endl '\n'
#define int long long
#define pb push_back
#define pii pair<int, int>
#define FU(i, a, b) for (int i = (a); i <= (b); ++i)
#define FD(i, a, b) for (int i = (a); i >= (b); --i)
const int MOD = 1e9 + 7;

const int inf = 1e9 + 7;  // 表示无穷大的容量
const int maxn = 1e4 + 5; // 最大节点数

// 边的结构体
struct edge {
    int from, to; // 边的起点和终点
    int cap;      // 边的容量
    int flow;     // 边当前的流量
    edge(int u, int v, int c, int f) : from(u), to(v), cap(c), flow(f) {}
};

// Dinic算法实现类
struct Dinic {
    int n, m;           // 节点数、边数
    int s, t;           // 源点、汇点
    vector<edge> edges; // 所有边的集合，边数两倍（包含反向边）
    vector<int> G[maxn]; // 邻接表，G[i]保存节点i的所有边在edges中的索引
    bool vis[maxn]; // BFS使用的访问标记数组
    int d[maxn];    // 层次网络中各节点的层次（距离）
    int cur[maxn]; // 当前弧优化数组，记录每个节点当前处理的边

    void init(int n) { // 初始化，n为节点数
        this->n = n;
        for (int i = 0; i < n; i++)
            G[i].clear();
        edges.clear();
    }

    // 清空所有边的流量，用于多次计算不同流的情况
    void clear() {
        for (int i = 0; i < edges.size(); i++)
            edges[i].flow = 0;
    }

    // 将边的容量减去已使用的流量，用于调整残余网络
    void reduce() {
        for (int i = 0; i < edges.size(); i++)
            edges[i].cap -= edges[i].flow;
    }

    // 添加一条从from到to，容量为cap的有向边及其反向边
    void addedge(int from, int to, int cap) {
        edges.push_back(edge(from, to, cap, 0)); // 正向边，初始流量0
        edges.push_back(edge(to, from, 0, 0)); // 反向边，初始容量0，流量0
        m = edges.size();
        G[from].push_back(m - 2); // 记录正向边在edges中的索引
        G[to].push_back(m - 1);   // 记录反向边在edges中的索引
    }

    // BFS构建层次网络，返回是否存在从s到t的路径
    bool BFS() {
        memset(vis, 0, sizeof(vis));
        queue<int> Q;
        Q.push(s); // 源点入队
        vis[s] = true;
        d[s] = 0;
        while (!Q.empty()) {
            int x = Q.front();
            Q.pop();
            for (int i = 0; i < G[x].size(); i++) { // 遍历x的所有邻接边
                edge &e = edges[G[x][i]];
                // 若边的终点未访问，且仍有剩余容量
                if (!vis[e.to] && e.cap > e.flow) {
                    vis[e.to] = true;
                    d[e.to] = d[x] + 1; // 层次+1
                    Q.push(e.to);
                }
            }
        }
        return vis[t]; // 返回汇点是否可达
    }

    // DFS寻找增广路径，x为当前节点，a为当前路径上的最小剩余容量
    int DFS(int x, int a) {
        if (x == t || a == 0) // 若到达汇点或剩余容量为0，直接返回
            return a;
        int flow = 0, f;
        // 使用当前弧优化，避免重复访问已经处理过的边
        for (int &i = cur[x]; i < G[x].size(); i++) {
            edge &e = edges[G[x][i]];
            // 层次递增且存在剩余容量
            if (d[x] + 1 == d[e.to] &&
                (f = DFS(e.to, min(a, e.cap - e.flow))) > 0) {
                e.flow += f;                  // 更新正向边流量
                edges[G[x][i] ^ 1].flow -= f; // 反向边流量减少（允许反向增广）
                flow += f;                    // 累加到总流量
                a -= f;                       // 剩余容量减少
                if (a == 0)
                    break; // 剩余容量为0，无需继续搜索
            }
        }
        if (flow == 0)
            d[x] = -2; // 炸点优化
        return flow;
    }

    // 计算从s到t的最大流
    int Maxflow(int s, int t) {
        this->s = s;
        this->t = t;
        int flow = 0;
        while (BFS()) {                  // 每次BFS构建层次网络
            memset(cur, 0, sizeof(cur)); // 重置当前弧
            flow += DFS(s, inf);         // 进行多路增广，累加流量
        }
        return flow;
    }
} dinic;

int N, M, k;

int id(int x, int y, int z) { return (x - 1) * (z + 1) + y; }
vector<int> G[35];
bool check(int d) {
    dinic.init(N * (d + 1) + 5);
    dinic.clear();
    int s = N * (d + 1) + 1, t = N * (d + 1) + 2;
    dinic.addedge(s, id(1, 0, d), inf);
    for (int i = 0; i <= d; i++)
        dinic.addedge(id(N, i, d), t, inf);
    for (int i = 1; i <= N; i++) {
        for (auto j : G[i]) {
            for (int k = 0; k <= d; k++) {
                dinic.addedge(id(i, k, d), id(j, k, d), 1);
                if (k != d)
                    dinic.addedge(id(i, k, d), id(j, k + 1, d), inf);
            }
        }
    }
    int flow = dinic.Maxflow(s, t);
    return (flow <= k);
}
signed main() {
    cin.tie(0)->ios::sync_with_stdio(0);
    cin >> N >> M >> k;

    for (int i = 1; i <= M; ++i) {
        int u, v;
        cin >> u >> v;
        G[u].push_back(v);
    }
    // int d;
    // cin>>d;
    // for(int i=0;i<=d;i++)
    // cout<<id(N, i, d)<<" ";

    int l = 0, r = k;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (check(mid)) {
            l = mid + 1;
        } else {
            r = mid - 1;
        }
    }
    cout <<r+1 ;

    return 0;
}