POJ 2112 思维构图 + dinic算法 + 二分

 思维构图参考了这篇博客：参考

 dinic的模板参考了这篇博客：参考

 数据比较水，EK算法也可以过。

 构建完图，套个二分，再套个dinic模板就可以了。这个模板比较好，层次简明，学到的地方  很多。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#define INF 0x3f3f3f3f
using namespace std;
const int maxv = 300;
const int maxe = 91000;

int K, C, M, n, src, dst;
int mmap[maxv][maxv];

/*******************Dinic模板**********************/
struct Edge {//因为有的时候（比如求最小割）外部需要用到遍信息，为了方便，把边放到class外面
    int from, to, cap, next;
} edge[maxe];
int cnt, head[maxv];
void edgeinit() {
    cnt = 0;
    memset(head, -1, sizeof head);
}
void addedge(int from, int to, int cap) {
    edge[cnt].from = from;
    edge[cnt].to = to;
    edge[cnt].cap = cap;
    edge[cnt].next = head[from];
    head[from] = cnt++;
    ;
    edge[cnt].from = to;
    edge[cnt].to = from;
    edge[cnt].cap = 0;
    edge[cnt].next = head[to];
    head[to] = cnt++;
}
/***************上面为建边，下面为Dinic**********************/
class Dinic {
private:
    int s, t, n, depth[maxv], cur[maxe]; //cur为当前狐优化
public:
    void init(int _s, int _t) {//这个模板只需要接受两个参数，一个是源点一个是汇点
        s = _s, t = _t;
    }
    int Dfs(int u, int dist) {
        if (u == t)
            return dist;
        for (int& i = cur[u]; i != -1; i = edge[i].next) {//注意这里的取址符
            if (depth[edge[i].to] == depth[u] + 1 && edge[i].cap != 0) {
                int delta = Dfs(edge[i].to, min(dist, edge[i].cap));
                if (delta > 0) {
                    edge[i].cap -= delta;
                    edge[i ^ 1].cap += delta;
                    return delta;
                }
            }
        }
        return false;
    }
    int Bfs() {
        queue<int> Q;
        memset(depth, 0, sizeof depth);
        depth[s] = 1;
        Q.push(s);
        while (!Q.empty()) {
            int u = Q.front();
            Q.pop();
            for (int i = head[u]; i != -1; i = edge[i].next) {
                if (edge[i].cap > 0 && depth[edge[i].to] == 0) {
                    depth[edge[i].to] = depth[u] + 1;
                    Q.push(edge[i].to);
                }
            }
        }
        if (depth[t] > 0)
            return true;
        return false;
    }
    int maxFlow() {
        int ans = 0;
        while (Bfs()) {
            for (int i = 0; i < cnt; i++)
                cur[i] = head[i];//cur是当前弧度优化，可以优化dfs的速度，但是dfs完后要初始化
            while (int delta = Dfs(s, INF))
                ans += delta;
        }
        return ans;
    }
} DC;
/*******************Dinic模板**********************/

void init() {//处理源点汇点以及图初始化
    src = 0; //源点
    dst = K + C + 1; //汇点
    n = K + C;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            mmap[i][j] = (i == j ? 0 : INF);
}
void Floyd() {
    for (int k = 1; k <= n; k++)
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                mmap[i][j] = min(mmap[i][j], mmap[i][k] + mmap[j][k]);
}

bool solve2(int limit) {//对边赋值以及调用Dinic模板
    edgeinit();
    DC.init(src, dst);
    for (int i = 1; i <= C; i++)
        addedge(src, K + i, 1);
    for (int i = 1; i <= K; i++)
        addedge(i, dst, M);
    for (int i = 1; i <= C; i++)
        for (int j = 1; j <= K; j++)
            if (mmap[i + K][j] <= limit)
                addedge(i + K, j, 1);
    return DC.maxFlow() == C;
}
void solve() {//二分搜索，找到最大距离的最小值
    int l = 0, r = 0;
    for (int i = 1; i <= n; i++)
        for (int j = i + 1; j <= n; j++)
            if (mmap[i][j] < INF)
                r = max(r, mmap[i][j]);
    while (l < r) {
        int m = l + (r - l) / 2;
        if (solve2(m))
            r = m;
        else
            l = m + 1;
    }
    cout << r << endl;
}
int main(void) {
    while (cin >> K >> C >> M) {
        init();
        int temp;
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                cin >> temp, mmap[i][j] = (i != j && temp == 0 ? INF : temp);//题目说了，距离为0表示不可到达，所以我们设置为INF
        Floyd();
        solve();
    }
    return 0;
}