网络流

真的是浅浅的了解了一下网络流。
其中增广路径和残余网络，需要理解清楚，这对于算法的理解是有帮助的。
可以看看别人上传的资料，资料（我也想传，不知道是不是侵权）。
也推荐一个图解比较详细的博客，图解。
接下去就看模板题和Dinic模板吧。

---

poj3281

/*
 *Memory 0.8
 *Time 79
 *本题居然和网络流有关，我的天啊，原谅我的见识短浅
 *全程套用《挑战程序设计竞赛第二版》模板
 *此题用到了Dinic算法和拆点技巧
 *边的容量都是 1 ，如果牛能按照题意选择正确的食物和饮料
 *那么从S到T的流量增加 1
*/
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
const int MAXN = 408;
const int MAXF = 102;
const int MAXD = 102;
const int INF = 1<<30;
struct Edge{
    int to, cap, rev;
};//下一节点，容量，反向边
vector <Edge> G[MAXN];
int level[MAXN], iter[MAXN];
bool likeF[MAXN][MAXF], likeD[MAXN][MAXD];
void addEdge(int u, int v, int cap) {
    G[u].push_back((Edge) {v, cap, G[v].size()});
    G[v].push_back((Edge) {u, 0, G[u].size() - 1});
}
void bfs(int s, int n) {
    for(int i = 0; i <= n; ++i) level[i] = -1;
    queue<int> Q;
    level[s] = 0;
    Q.push(s);
    while(!Q.empty()) {
        int v = Q.front(); Q.pop();
        for(int i = 0; i < G[v].size(); ++i) {
            Edge &e = G[v][i];
            if(e.cap > 0 && level[e.to] < 0) {
                level[e.to] = level[v] + 1;
                Q.push(e.to);
            }
        }
    }
}
int dfs(int v, int t, int f) {
    if(v == t) return f;
    for(int &i = iter[v]; i < G[v].size(); ++i) {
        Edge &e = G[v][i];
        if(e.cap > 0 && level[v] < level[e.to]) {
            int d = dfs(e.to, t, min(f, e.cap));
            if(d > 0) {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}
int maxFlow(int s, int t, int n) {
    int flow = 0;
    while(true) {
        bfs(s, n);
        if(level[t] < 0) return flow;
        for(int i = 0; i <= n; ++i) iter[i] = 0;
        int f;
        while((f = dfs(s, t, INF)) > 0) flow += f;
    }
}
void solve(int n, int f, int d) {
    //0 - n-1：表示食物一侧的牛
    //n - 2n-1：表示饮料一侧的牛
    //2n - 2n+f-1：表示食物
    //2n+f - 2n+f+d-1：表示饮料
    int s = 2 * n + f + d, t = s + 1;
    for(int i = 0; i < f; ++i) addEdge(s, 2 * n + i, 1);
    for(int i = 0; i < d; ++i) addEdge(2 * n + f + i, t, 1);
    for(int i = 0; i < n; ++i) {
        addEdge(i, n + i, 1);
        for(int j = 0; j < f; ++j)
            if(likeF[i][j]) addEdge(2 * n + j, i, 1);
        for(int j = 0; j < d; ++j)
            if(likeD[i][j]) addEdge(n + i, 2 * n + f + j, 1);
    }
    cout<<maxFlow(s, t, t)<<endl;
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int N, F, D;
    int f, d, fi, di;
    while(cin>>N>>F>>D) {
        for(int i = 0; i <= N; ++i)
            for(int j = 0; j <= N; ++j)
                likeD[i][j] = likeF[i][j] = false;
        for(int i = 0; i <= N; ++i) G[i].clear();

        for(int i = 0; i < N; ++i) {
            cin>>f>>d;
            for(int j = 0; j < f; ++j) {
                cin>>fi;
                likeF[i][fi - 1] = true;
            }
            for(int j = 0; j < d; ++j) {
                cin>>di;
                likeD[i][di - 1] = true;
            }
        }
        solve(N, F, D);
    }
    return 0;
}

Dinic算法模板：

struct Edge{
    int to, cap, rev;
};
vector <Edge> G[MAXN];
int level[MAXN], iter[MAXN];

void addEdge(int u, int v, int cap) {
    G[u].push_back((Edge) {v, cap, G[v].size()});
    G[v].push_back((Edge) {u, 0, G[u].size() - 1});
}
void bfs(int s, int n) {
    for(int i = 0; i <= n; ++i) level[i] = -1;
    queue<int> Q;
    level[s] = 0;
    Q.push(s);
    while(!Q.empty()) {
        int v = Q.front(); Q.pop();
        for(int i = 0; i < (int)G[v].size(); ++i) {
            Edge &e = G[v][i];
            if(e.cap > 0 && level[e.to] < 0) {
                level[e.to] = level[v] + 1;
                Q.push(e.to);
            }
        }
    }
}
int dfs(int v, int t, int f) {
    if(v == t) return f;
    for(int &i = iter[v]; i < G[v].size(); ++i) {
        Edge &e = G[v][i];
        if(e.cap > 0 && level[v] < level[e.to]) {
            int d = dfs(e.to, t, min(f, e.cap));
            if(d > 0) {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}
int maxFlow(int s, int t, int n) {
    int flow = 0;
    while(true) {
        bfs(s, n);
        if(level[t] < 0) return flow;
        for(int i = 0; i <= n; ++i) iter[i] = 0;
        int f;
        while((f = dfs(s, t, INF)) > 0) flow += f;
    }
}

---

如果以后有时间在怼它（~.~）