URAL 1774 Barber of the Army of Mages 最大流

思路：

　　以理发的次数当容量，源点到每个人建一条容量为2的边，人到他可达的每个时间点建一条边，每个时间点到汇点建一条容量为m的边。然后判断最大流是否等于2*n。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <string>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <functional>
#include <time.h>

using namespace std;


using namespace std;

const int INF = 1<<30;
const int MAXN = 3000;
const int MAXE = (int)5e5+10;

struct Dinic{
    struct Edge {
        int from, to, cap, flow;
        //从from到to的容量为cap，流量为flow的弧
    };

    int n, m, s, t; //结点数，边数（包括反向弧），源点，汇点
    vector<Edge> edges; //边表。 edges[e]和edges[e^1]互为反向弧
    vector<int> G[MAXN]; //邻接表，G[i][j]表示结点i的第j条边在e数组中的序号
    bool vis[MAXN]; //bfs使用
    int d[MAXN]; //从起点到i的距离
    int cur[MAXN]; //当前弧下标

    inline void init() {
        edges.clear();
        for (int i = 0; i <= n; i++) {
            G[i].clear();
        }
    }

    inline void addEdge(int from, int to, int cap) {
        edges.push_back((Edge){from, to, cap, 0});
        edges.push_back((Edge){to, from, 0, 0});
        m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool bfs() {
        memset(vis, false, sizeof(vis));
        queue<int> q;
        q.push(s);
        d[s] = 0;
        vis[s] = true;

        while (!q.empty()) {
            int u = q.front(); q.pop();
            for (int i = 0; i < G[u].size(); i++) {
                Edge &e = edges[G[u][i]];
                if (!vis[e.to] && (e.cap > e.flow)) { //只考虑残量网络中的弧
                    vis[e.to] = true;
                    d[e.to] = d[u]+1;
                    q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int dfs(int u, int c) {
        if (u==t || 0==c) return c;
        int flow = 0, f;
        for (int &i = cur[u]; i < G[u].size(); i++) { //从上次考虑的弧
            Edge &e = edges[G[u][i]];
            if ((d[u]+1)==d[e.to] && (f = dfs(e.to, min(c, e.cap-e.flow))) > 0) {
                e.flow += f;
                edges[G[u][i]^1].flow -= f;
                flow += f;
                c -= f;
                if (0==c) break;
            }
        }
        return flow;
    }

    int MaxFlow(int s, int t) {
        this->s = s; this->t = t;
        int flow = 0;
        while (bfs()) {
            memset(cur, 0, sizeof(cur));
            flow += dfs(s, INF);
        }
        return flow;
    }
    void print(int st, int ed) {
        for (int i = st; i < ed; i++) {
            bool flag = false;
            for (int j = 0; j < G[i].size(); j++) {
                Edge &e = edges[G[i][j]];
                if (e.flow==1) {
                    if (flag) printf(" ");
                    printf("%d", e.to);
                    if (flag) {
                        puts("");
                        break;
                    }
                    flag = true;
                }
            }
        }
    }
};

Dinic a;
int n, m;

void solve() {
    // 时间点： 0~2000
    // 人: 2001~2000+n
    //s: 0, t: 2001+n
    int s = 2001+n;
    int t = s+1;
    a.n = t;
    a.init();
    int x, y;
    int Max = 0;
    for (int i = 0; i < n; i++)
        a.addEdge(s, 2001+i, 2);

    for (int i = 0; i < n; i++) {
        scanf("%d%d", &x, &y);
        Max = max(Max, x+y);
        for (int j = 0; j < y; j++) {
            a.addEdge(2001+i, x+j, 1);
        }
    }
    for (int i = 0; i <= Max; i++)
        a.addEdge(i, t, m);
    int ans = a.MaxFlow(s, t);
    if (2*n==ans) {
        puts("Yes");
        a.print(2001, 2001+n);
    } else
        puts("No");
}

int main() {
    #ifdef Phantom01
        freopen("A.txt", "r", stdin);
    #endif // Phantom01

    while (scanf("%d%d", &n, &m)!=EOF) {
        solve();
    }

    return 0;
}

其实做这个题，是为了检验更学的新模板 Dinic