最大流最小割费用流初步

2015年11月23日

　　网络流24题<1> COGS 14

　　　　二分图匹配。

　　　　Dinic:

#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define drep(i, a, b) for (int i = a; i >= b; i--)
#define REP(i, a, b) for (int i = a; i < b; i++)
#define pb push_back
#define mp make_pair
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second
using namespace std;
typedef long long i64;
typedef pair<int, int> pii;
const int inf = ~0U>>1;
const i64 INF = ~0ULL>>1;
//***************************

const int maxn = 105;
struct Ed {
    int u, v, nx, c; Ed() {}
    Ed(int _u, int _v, int _nx, int _c) :
        u(_u), v(_v), nx(_nx), c(_c) {}
} E[3005];
int G[105], cnt;
void addedge(int x, int y, int v) {
    E[cnt] = Ed(x, y, G[x], v);
    G[x] = cnt++;
    E[cnt] = Ed(y, x, G[y], 0);
    G[y] = cnt++;
}

int s, t;

int level[maxn];
bool bfs() {
    static int que[maxn]; int qt(0), qh(0);
    clr(level);
    level[que[++qt] = s] = 1;
    while (qt != qh) {
        int x = que[++qh];
        for (int i = G[x]; i != -1; i = E[i].nx) if (E[i].c && !level[E[i].v])
            level[que[++qt] = E[i].v] = level[x] + 1;
    }
    return !!level[t];
}
int dfs(int u, int rm) {
    if (u == t) return rm;
    int rm1 = rm;
    for (int i = G[u]; i != -1; i = E[i].nx) {
        if (E[i].c && level[E[i].v] == level[u] + 1) {
            int flow = dfs(E[i].v, min(E[i].c, rm));
            E[i].c -= flow, E[i ^ 1].c += flow;
            if ((rm -= flow) == 0) break;
        }
    }
    if (rm1 == rm) level[u] = 0;
    return rm1 - rm;
}

int main() {
    freopen("flyer.in", "r", stdin);
    freopen("flyer.out", "w", stdout);
    int n, n1;
    while (~scanf("%d%d", &n, &n1)) {
        s = 0, t = n + 1;
        memset(G, -1, sizeof(G));
        int x, y;
        while (~scanf("%d%d", &x, &y)) addedge(x, y, 1);
        rep(i, 1, n1) addedge(s, i, 1);
        rep(i, n1 + 1, n) addedge(i, t, 1);
        int ans(0);
        while (bfs()) ans += dfs(s, 0x3f3f3f3f);
        printf("%d
", ans);
    }
    fclose(stdin);
    fclose(stdout);
    return 0;
}

　　　　匈牙利:

#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define drep(i, a, b) for (int i = a; i >= b; i--)
#define REP(i, a, b) for (int i = a; i < b; i++)
#define pb push_back
#define mp make_pair
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second
using namespace std;
typedef long long i64;
typedef pair<int, int> pii;
const int inf = ~0U>>1;
const i64 INF = ~0ULL>>1;
//***************************

const int maxn = 105;
struct Ed {
    int u, v, nx, c; Ed() {}
    Ed(int _u, int _v, int _nx) :
        u(_u), v(_v), nx(_nx) {}
} E[3005];
int G[105], cnt;
void addedge(int x, int y) {
    E[cnt] = Ed(x, y, G[x]);
    G[x] = cnt++;
}

bool used[maxn];
int girl[maxn];
bool find(int x) {
    for (int i = G[x]; i != -1; i = E[i].nx) {
        if (used[E[i].v]) continue;
        used[E[i].v] = 1;
        if (!girl[E[i].v] || find(girl[E[i].v])) {
            girl[E[i].v] = x;
            return true;
        }
    }
    return false;
}
int main() {
    freopen("flyer.in", "r", stdin);
    freopen("flyer.out", "w", stdout);
    int n, n1;
    while (~scanf("%d%d", &n, &n1)) {
        int x, y;
        memset(G, -1, sizeof(G));
        while (~scanf("%d%d", &x, &y)) {
            addedge(x, y);
        }
        clr(girl);
        int ans(0);
        rep(i, 1, n1) {
            clr(used);
            if (find(i)) ans++;
        }
        printf("%d
", ans);
    }
    
}

　　网络流24题<2> COGS 727

　　　　该问题的一般模型为最大权闭合图。

　　　　[建模方法]

　　　　　　把每个实验看作二分图X集合中的顶点，每个设备看作二分图Y集合中的顶点，增加源S和汇T。
　　　　　　1、从S向每个Xi连接一条容量为该点收入的有向边。
　　　　　　2、从Yi向T连接一条容量为该点支出的有向边。
　　　　　　3、如果一个实验i需要设备j，连接一条从Xi到Yj容量为无穷大的有向边。

　　　　用割来确定答案。

　　　　设S-T割中的S割为选定的答案，A为实验集合，B为器材编号。

　　　　　　ans:被选中的A集合中的顶点的权值 - 被选中的B集合中的顶点的权值

　　　　　　Cut:没有被选中的A集合中的顶点的权值 + 被选中的B集合中的顶点的权值 + 被选中的A集合中与没有被选中的B集合中的边的Sum (一些inf的和)
　　　　　　Total:所有A集合中的顶点的权值
　　　　　　Total - Cut = ans
　　　　　　最小割时没有Cut里的第三项，所以最小化Cut，最大流。

#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define drep(i, a, b) for (int i = a; i >= b; i--)
#define REP(i, a, b) for (int i = a; i < b; i++)
#define pb push_back
#define mp make_pair
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second
using namespace std;
typedef long long i64;
typedef pair<int, int> pii;
const int inf = 0x3f3f3f3f;
const i64 INF = ~0ULL>>1;
//***************************

const int maxn = 205;
struct Ed {
    int u, v, nx, c; Ed() {}
    Ed(int _u, int _v, int _nx, int _c) :
        u(_u), v(_v), nx(_nx), c(_c) {}
} E[10205];
int G[maxn], cnt;
void addedge(int x, int y, int v) {
    E[cnt] = Ed(x, y, G[x], v);
    G[x] = cnt++;
    E[cnt] = Ed(y, x, G[y], 0);
    G[y] = cnt++;
}

int s, t;
int level[maxn];
bool bfs() {
    static int que[maxn]; int qh(0), qt(0);
    clr(level);
    level[que[++qt] = s] = 1;
    while (qh != qt) {
        int x = que[++qh];
        for (int i = G[x]; i != -1; i = E[i].nx) if (E[i].c && !level[E[i].v]) 
            level[que[++qt] = E[i].v] = level[x] + 1;
    }
    return !!level[t];
}
int dfs(int u, int rm) {
    if (u == t) return rm;
    int rm1 = rm;
    for (int i = G[u]; i != -1; i = E[i].nx) {
        if (E[i].c && level[E[i].v] == level[u] + 1) {
            int flow = dfs(E[i].v, min(rm, E[i].c));
            E[i].c -= flow, E[i ^ 1].c += flow;
            if ((rm -= flow) == 0) break;
        }
    }
    if (rm1 == rm) level[u] = 0;
    return rm1 - rm;
}

char ch[100005];
int main() {
    freopen("shuttle.in", "r", stdin);
    freopen("shuttle.out", "w", stdout);
    int n, m;
    int tot(0);
    scanf("%d%d", &n, &m);
    memset(G, -1, sizeof(G));
    s = 0, t = n + m + 1;
    rep(i, 1, n) {
        int val;
        scanf("%d ", &val);
        tot += val;
        addedge(s, i, val);
        fgets(ch, 100000, stdin);
        int id(0);
        for (int j = 0; ch[j]; j++) {
            if (ch[j] == ' ' || ch[j] == '
' || ch[j] == '
') {
                if (id) addedge(i, id + n, inf);
                id = 0;
            }
            else {
                id = id * 10 + ch[j] - '0';
            }
        }
    }
    rep(i, 1, m) {
        int val;
        scanf("%d", &val);
        addedge(n + i, t, val);
    }
    int ans(0);
    while (bfs()) ans += dfs(s, 0x3f3f3f3f);
    rep(i, 1, n) if (level[i]) printf("%d ", i);
    puts("");
    rep(i, 1, m) if (level[i + n]) printf("%d ", i);
    puts("");
    printf("%d
", tot - ans);
    return 0;
}

　　网络流24题<3> COGS 728

　　　　二分图最大匹配。假设一开始n个点自己是一条链，那么此时有n条链，假设可以匹配一个，那么路径数就会减一，所以跑出最大匹配即可。

　　　　懒，只写了dinic:

#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define drep(i, a, b) for (int i = a; i >= b; i--)
#define REP(i, a, b) for (int i = a; i < b; i++)
#define pb push_back
#define mp make_pair
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second
using namespace std;
typedef long long i64;
typedef pair<int, int> pii;
const int inf = 0x3f3f3f3f;
const i64 INF = ~0ULL>>1;
//***************************

const int maxn = 305;

struct Ed {
    int u, v, c, nx; Ed() {}
    Ed(int _u, int _v, int _c, int _nx) :
        u(_u), v(_v), c(_c), nx(_nx) {}
} E[13005];
int G[305], cnt;
void addedge(int u, int v, int c) {
    E[cnt] = Ed(u, v, c, G[u]);
    G[u] = cnt++;
    E[cnt] = Ed(v, u, 0, G[v]);
    G[v] = cnt++;
}

int level[maxn];
int s, t;
bool bfs() {
    static int que[305]; int qh(0), qt(0);
    clr(level);
    level[que[++qt] = s] = 1;
    while (qh != qt) {
        int x = que[++qh];
        for (int i = G[x]; i != -1; i = E[i].nx) if (E[i].c && !level[E[i].v])
            level[que[++qt] = E[i].v] = level[x] + 1;
    }
    return !!level[t];
}
int dfs(int u, int rm) {
    if (u == t) return rm;
    int rm1 = rm;
    for (int i = G[u]; i != -1; i = E[i].nx) {
        if (E[i].c && level[E[i].v] == level[u] + 1) {
            int flow = dfs(E[i].v, min(rm, E[i].c));
            E[i].c -= flow, E[i ^ 1].c += flow;
            if ((rm -= flow) == 0) break;
        }
    }
    if (rm1 == rm) level[u] = 0;
    return rm1 - rm;
}

int main() {
    freopen("path3.in", "r", stdin);
    freopen("path3.out", "w", stdout);
    int n, m;
    scanf("%d%d", &n, &m);
    s = 0, t = (n << 1) + 1;
    memset(G, -1, sizeof(G));
    rep(i, 1, m) {
        int x, y;
        scanf("%d%d", &x, &y);
        addedge(x, y + n, 1);
    }
    rep(i, 1, n) {
        addedge(s, i, 1);
        addedge(i + n, t, 1);
    }
    while (bfs()) dfs(s, 0x3f3f3f3f);
    static int nxt[maxn], frm[maxn];
    rep(i, 1, n) {
        for (int j = G[i]; j != -1; j = E[j].nx) {
            if (E[j].v <= n) continue;
            if (E[j].c == 0) {
                nxt[i] = E[j].v - n, frm[E[j].v - n] = i;
                break;
            }
        }
    }
    int ans(0);
    rep(i, 1, n) {
        if (frm[i] == 0) {
            int k = i;
            while (k) {
                printf("%d ", k);
                k = nxt[k];
            }
            puts("");
            ans++;
        }
    }
    printf("%d
", ans);
    fclose(stdin);
    fclose(stdout);
    return 0;
}

　　　　匈牙利算法请见友链中的Ngshily.   http://www.cnblogs.com/Ngshily/p/4988909.html

　　　　

　　bzoj 3996

　　　　同类与网络流24题<2>，最大权闭合图。

　　　　D =（A * B - C）* A^T；

　　　　E = A * B;

　　　　Eij = sigma(k = (1 ~ n)) Aik * Bkj；因为 E为[1，n]的矩阵 把Eij表示为Ej.

　　　　Ej = sigma(k = (1 ~ n)) Ak * Bkj;

　　　　设F = E * A^T;

　　　　F(1, 1) = sigma(p = 1 ~n) Ep * Ap;

　　　　代入得 F = sigma(p = 1 ~ n) (sigma(k = 1 ~ n) Ak * Bkp * Ap)

　　　　

　　　　G = C * A^T

　　　　G = sigma(k, 1, n) Ck * Ak；

　　　　由此可见，若要取得Bkp，则Ak和Ap必须为1，也就是Bij依赖Ai和Aj，后面的式子则是Ai的选取代价，所以得到了最大权闭合图的模型。

#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define drep(i, a, b) for (int i = a; i >= b; i--)
#define REP(i, a, b) for (int i = a; i < b; i++)
#define pb push_back
#define mp make_pair
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second
using namespace std;
typedef long long i64;
typedef pair<int, int> pii;
const int inf = 0x3f3f3f3f;
const i64 INF = ~0ULL>>1;
//***************************
 
const int maxn = 260005;
const int maxm = 751005;
 
struct Ed {
    int u, v, nx, c; Ed() {}
    Ed(int _u, int _v, int _nx, int _c) :
        u(_u), v(_v), nx(_nx), c(_c) {}
} E[maxm << 1];
int G[maxn], cnt;
void addedge(int u, int v, int c) {
    E[cnt] = Ed(u, v, G[u], c);
    G[u] = cnt++;
    E[cnt] = Ed(v, u, G[v], 0);
    G[v] = cnt++;
}
 
int s, t;
int level[maxn];
bool bfs() {
    static int que[maxn]; int qh(0), qt(0);
    clr(level);
    level[que[++qt] = s] = 1;
    while (qh != qt) {
        int x = que[++qh];
        for (int i = G[x]; i != -1; i = E[i].nx) if (E[i].c && !level[E[i].v])
            level[que[++qt] = E[i].v] = level[x] + 1;
    }
    return !!level[t];
}
int dfs(int u, int rm) {
    if (u == t) return rm;
    int rm1 = rm;
    for (int i = G[u]; i != -1; i = E[i].nx) {
        if (E[i].c && level[E[i].v] == level[u] + 1) {
            int flow = dfs(E[i].v, min(E[i].c, rm));
            E[i].c -= flow, E[i ^ 1].c += flow;
            if ((rm -= flow) == 0) break;
        }
    }
    if (rm1 == rm) level[u] = 0;
    return rm1 - rm;
}
 
int main() {
    int n;
    scanf("%d", &n);
    s = 0, t = n * n + n + 1;
    memset(G, -1, sizeof(G));
    int tot(0);
    REP(i, 0, n) rep(j, 1, n) {
        int id;
        scanf("%d", &id);
        tot += id;
        addedge(s, i * n + j, id);
        addedge(i * n + j, i + n * n + 1, inf);
        addedge(i * n + j, j + n * n, inf);
    }
    rep(i, 1, n) {
        int id;
        scanf("%d", &id);
        addedge(n * n + i, t, id);
    }
    int ans(0);
    while (bfs()) ans += dfs(s, 0x3f3f3f3f);
    printf("%d
", tot - ans);
    return 0;
}

　　

　　网络流24题<5> COGS 729 圆桌问题

　　　　类似于二分图匹配，给每个单位连他们人数的流量，每个单位依次给每个桌子连1的流量，每个桌子依次给超级汇点连桌子的容量的流量。

　　　　dinic即可。

#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define drep(i, a, b) for (int i = a; i >= b; i--)
#define REP(i, a, b) for (int i = a; i < b; i++)
#define pb push_back
#define mp make_pair
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second
using namespace std;
typedef long long i64;
typedef pair<int, int> pii;
const int inf = 0x3f3f3f3f;
const i64 INF = ~0ULL>>1;
//***************************

const int maxn = 505;
const int maxm = 41000;

struct Ed {
    int u, v, nx, c; Ed() {}
    Ed(int _u, int _v, int _nx, int _c) :
        u(_u), v(_v), nx(_nx), c(_c) {}
} E[maxm << 1];
int G[maxn], cnt;
void addedge(int u, int v, int c) {
    E[cnt] = Ed(u, v, G[u], c);
    G[u] = cnt++;
    E[cnt] = Ed(v, u, G[v], 0);
    G[v] = cnt++;
}

int s, t;
int level[maxn];
bool bfs() {
    static int que[maxn]; int qh(0), qt(0);
    clr(level);
    level[que[++qt] = s] = 1;
    while (qh != qt) {
        int x = que[++qh];
        for (int i = G[x]; i != -1; i = E[i].nx) if (E[i].c && !level[E[i].v])
            level[que[++qt] = E[i].v] = level[x] + 1;
    }
    return !!level[t];
}
int dfs(int u, int rm) {
    if (u == t) return rm;
    int rm1 = rm;
    for (int i = G[u]; i != -1; i = E[i].nx) {
        if (E[i].c && level[E[i].v] == level[u] + 1) {
            int flow = dfs(E[i].v, min(rm, E[i].c));
            E[i].c -= flow, E[i ^ 1].c += flow;
            if ((rm -= flow) == 0) break;
        }
    }
    if (rm1 == rm) level[u] = 0;
    return rm1 - rm;
}

int main() {
    freopen("roundtable.in", "r", stdin);
    freopen("roundtable.out", "w", stdout);
    int n, m;
    scanf("%d%d", &n, &m);
    s = 0, t = n + m + 1;
    memset(G, -1, sizeof(G));
    int tot(0);
    rep(i, 1, n) {
        int id;
        scanf("%d", &id);
        tot += id;
        addedge(s, i, id);
    }
    rep(i, 1, n) rep(j, 1, m) addedge(i, n + j, 1);
    rep(i, 1, m) {
        int id;
        scanf("%d", &id);
        addedge(n + i, t, id);
    }
    int ans(0);
    while (bfs()) ans += dfs(s, 0x3f3f3f3f);
    if (ans < tot) puts("0");
    else puts("1");
    static int sta[maxn];
    int top(0);
    rep(i, 1, n) {
        for (int j = G[i]; j != -1; j = E[j].nx) {
            if (E[j].c == 0) {
                sta[++top] = E[j].v - n;
            }
        }
        drep(j, top, 1) printf("%d ", sta[j]);
        top = 0;
        puts("");
    }
    fclose(stdin);
    fclose(stdout);
    return 0;
}

2015年11月24日

　　网络流24题 COGS 魔术球问题

　　　　最小路径覆盖问题。

　　　　先二分答案，建图dinic即可，有一点需要注意，在连边时，i 只能向 i + 1 及其以后的边连边，否则不符合实际意义，也会使二分图满流。

#include <bits/stdc++.h>
#define rep(i, a, b) for (register int i = a; i <= b; i++)
#define drep(i, a, b) for (int i = a; i >= b; i--)
#define REP(i, a, b) for (int i = a; i < b; i++)
#define pb push_back
#define mp make_pair
#define clr(x) memset(x, 0, sizeof(x))
#define xx first
#define yy second
using namespace std;
typedef long long i64;
typedef pair<int, int> pii;
const int inf = 0x3f3f3f3f;
const i64 INF = ~0ULL>>1;
//***************************

const int maxn = 3205;
const int maxm = 38545;

struct Ed {
    int u, v, nx, c; Ed() {}
    Ed(int _u, int _v, int _nx, int _c) :
        u(_u), v(_v), nx(_nx), c(_c) {}
} E[maxm << 1];
int G[maxn], cnt;
void addedge(int u, int v, int c) {
    E[cnt] = Ed(u, v, G[u], c);
    G[u] = cnt++;
    E[cnt] = Ed(v, u, G[v], 0);
    G[v] = cnt++;
}

int level[maxn], s, t;
bool bfs() {
    static int que[maxn]; int qh(0), qt(0);
    clr(level);
    level[que[++qt] = s] = 1;
    while (qh != qt) {
        int x = que[++qh];
        for (int i = G[x]; i != -1; i = E[i].nx) if (E[i].c && !level[E[i].v])
            level[que[++qt] = E[i].v] = level[x] + 1;
    }
    return !!level[t];
}
int dfs(int u, int rm) {
    if (u == t) return rm;
    int rm1 = rm;
    for (int i = G[u]; i != -1; i = E[i].nx) {
        if (E[i].c && level[E[i].v] == level[u] + 1) {
            int flow = dfs(E[i].v, min(E[i].c, rm));
            E[i].c -= flow, E[i ^ 1].c += flow;
            if ((rm -= flow) == 0) break;
        }
    }
    if (rm1 == rm) level[u] = 0;
    return rm1 - rm;
}

int main() {
    freopen("balla.in", "r", stdin);
    freopen("balla.out", "w", stdout);
    int sho;
    scanf("%d", &sho);
    int low = 0, high = 1605;
    while (low < high - 1) {
        int mid = low + high >> 1;
        s = 0, t = (mid << 1) + 1;
        memset(G, -1, sizeof(G)); cnt = 0;
        rep(i, 1, mid) rep(j, i + 1, mid) {
            int sq = sqrt(1.0 * i + j);
            if (sq * sq == i + j) addedge(i, mid + j, 1);
        }
        rep(i, 1, mid) addedge(s, i, 1), addedge(i + mid, t, 1);
        int ans(0);
        while (bfs()) ans += dfs(s, 0x3f3f3f3f);
        if (mid - ans <= sho) low = mid;
        else high = mid;
    }
    printf("%d
", low);
    fclose(stdin);
    fclose(stdout);
    return 0;
}

2015年11月26日

　　网络流24题 10 餐巾计划

　　　　把每个点拆成两个点，一个是每天用掉的点，另一边为来源。

　　　　从S到用掉的点连接费用为0，容量为ri的边。

　　　　从来源的点向T连接费用为0，容量为ri的边。   来限制流量。

　　　　在用掉的点的集合中，i 向 i + 1 连接费用为0，容量为inf的边。

　　　　从S到来源集合中连接容量为inf，费用为P的边。

　　　　连上快洗和慢洗。

　　　　感觉第一个集合中的点中用作限制，第二个才是解决的方案。

　　　　zkw费用流：

#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define REP(i, a, b) for (int i = a; i < b; i++)
#define drep(i, a, b) for (int i = a; i >= b; i--)
#define clr(x) memset(x, 0, sizeof(x))
#define pb push_back
#define mp make_pair
#define xx first
#define yy second
using namespace std;
typedef long long i64;
typedef pair<int, int> pii;
const int inf = ~0U >> 1;
const i64 INF = ~0ULL >> 1;
//*****************************

const int maxn = 405, maxm = 40605;
struct Ed {
    int u, v, nx, c, s; Ed() {};
    Ed (int _u, int _v, int _nx, int _c, int _s) :
        u(_u), v(_v), nx(_nx), c(_c), s(_s) {}
} E[maxm << 1];
int G[maxn], cnt;
void addedge(int u, int v, int c, int s) {
    E[cnt] = Ed(u, v, G[u], c, s);
    G[u] = cnt++;
    E[cnt] = Ed(v, u, G[v], 0, -s);
    G[v] = cnt++;
}

int s, t;
int dis[maxn], vis[maxn];
bool spfa() {
    static int que[maxm]; int qh(0), qt(0);
    memset(dis, 0x3f, sizeof(dis));
    clr(vis);
    vis[que[++qt] = s] = 1; dis[s] = 0;
    while (qh != qt) {
        int x = que[++qh]; vis[x] = 0;
        for (int i = G[x]; i != -1; i = E[i].nx) {
            if (E[i].c && E[i].s + dis[x] < dis[E[i].v]) {
                dis[E[i].v] = dis[x] + E[i].s;
                if (!vis[E[i].v]) que[++qt] = E[i].v, vis[E[i].v] = 1;
            }
        }
    }
    return dis[t] != 0x3f3f3f3f;
}

int ans;
int dfs(int u, int rm) {
    vis[u] = 1;
    if (u == t) return rm;
    int rm1 = rm;
    for (int i = G[u]; i != -1; i = E[i].nx) {
        if (dis[u] + E[i].s == dis[E[i].v] && E[i].c && !vis[E[i].v]) {
            int flow = dfs(E[i].v, min(rm, E[i].c));
            E[i].c -= flow, E[i ^ 1].c += flow;
            ans += flow * E[i].s;
            if ((rm -= flow) == 0) break;
        }
    }
    if (rm1 == rm) dis[u] = 0;
    return rm1 - rm;
}

int a[maxn];
int main() {
    freopen("napkin.in", "r", stdin);
    freopen("napkin.out", "w", stdout);
    int n;
    scanf("%d", &n);
    rep(i, 1, n) scanf("%d", &a[i]);
    int P, M, F, N, S;
    scanf("%d%d%d%d%d", &P, &M, &F, &N, &S);
    memset(G, -1, sizeof(G)); s = 0, t = (n << 1) + 1;
    rep(i, 1, n) addedge(s, i, a[i], 0), addedge(s, n + i, inf, P), addedge(i + n, t, a[i], 0);
    REP(i, 1, n) addedge(i, i + 1, inf, 0);
    rep(i, 1, n) {
        if (i + M <= n) addedge(i, i + M + n, inf, F);
        if (i + N <= n) addedge(i, i + N + n, inf, S);
    }

    while (spfa()) clr(vis), dfs(s, 0x3f3f3f3f);
    printf("%d
", ans);
    fclose(stdin);
    fclose(stdout);
    return 0;
}

　　　　普通费用流：

#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define REP(i, a, b) for (int i = a; i < b; i++)
#define drep(i, a, b) for (int i = a; i >= b; i--)
#define pb push_back
#define mp make_pair
#define xx first
#define yy second
using namespace std;
typedef long long i64;
typedef pair<int, int> pii;
const int inf = ~0U >> 1;
const i64 INF = ~0ULL >> 1;
//*****************************

const int maxn = 405, maxm = 40605;
struct Ed {
    int u, v, nx, c, s; Ed() {};
    Ed (int _u, int _v, int _nx, int _c, int _s) :
        u(_u), v(_v), nx(_nx), c(_c), s(_s) {}
} E[maxm << 1];
int G[maxn], cnt;
void addedge(int u, int v, int c, int s) {
    E[cnt] = Ed(u, v, G[u], c, s);
    G[u] = cnt++;
    E[cnt] = Ed(v, u, G[v], 0, -s);
    G[v] = cnt++;
}

bool vis[maxn];
int s, t;
int pre[maxn];
bool spfa() {
    static int que[maxm]; int qh(0), qt(0);
    static int dis[maxn];
    memset(dis, 0x3f, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    vis[que[++qt] = s] = 1;
    dis[s] = 0;
    while (qh != qt) {
        int x = que[++qh];
        vis[x] = 0;
        for (int i = G[x]; i != -1; i = E[i].nx) {
            if (E[i].c && dis[x] + E[i].s < dis[E[i].v]) {
                dis[E[i].v] = dis[x] + E[i].s;
                pre[E[i].v] = i;
                if (!vis[E[i].v]) {
                    vis[E[i].v] = 1;
                    que[++qt] = E[i].v;
                }
            }
        }
    }
    if (dis[t] == 0x3f3f3f3f) return false;
    return true;
}

int a[maxn];
int main() {
    freopen("napkin.in", "r", stdin);
    freopen("napkin.out", "w", stdout);
    int n;
    scanf("%d", &n);
    rep(i, 1, n) scanf("%d", &a[i]);
    int P, M, F, N, S;
    scanf("%d%d%d%d%d", &P, &M, &F, &N, &S);

    memset(G, -1, sizeof(G));
    s = 0, t = (n << 1) + 1;
    rep(i, 1, n) { addedge(s, i, a[i], 0); addedge(i + n, t, a[i], 0); }
    REP(i, 1, n) addedge(i, i + 1, inf, 0);
    rep(i, 1, n) addedge(s, i + n, inf, P);
    rep(i, 1, n) {
        if (i + M <= n) addedge(i, i + M + n, inf, F);
        if (i + N <= n) addedge(i, i + N + n, inf, S);
    }
    int ans(0);
    pre[s] = -1;
    while (spfa()) {
        int flow = inf;
        for (int i = pre[t]; i != -1; i = pre[E[i].u]) {
            flow = min(flow, E[i].c);
        }
        for (int i = pre[t]; i != -1; i = pre[E[i].u]) {
            E[i].c -= flow, E[i ^ 1].c += flow;
            ans += flow * E[i].s;
        }
    }
    printf("%d
", ans);
}

　　网络流24题 11 航空路线问题

　　　　可以dp多线程。

　　　　同样，拆点，一个点为入点，一个为出点。

　　　　S到1的入点连接 【容量为2，费用为1】的边，n的出点连接 【容量为2，费用为0】的边，每条航线连接【容量为1，费用为1】的边，每个点出点到自己的入点连接【容量为1，费用为0】的边。(和第一个点和最后一个点相连的边容量均为2)。

　　　　如果最大流不够，-1。

　　　　因为要求最大费用最大流，所以把边权建成-1就好。

#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define REP(i, a, b) for (int i = a; i < b; i++)
#define drep(i, a, b) for (int i = a; i >= b; i--)
#define clr(x) memset(x, 0, sizeof(x))
#define pb push_back
#define mp make_pair
#define xx first
#define yy second
using namespace std;
typedef long long i64;
typedef pair<int, int> pii;
const int inf = ~0U >> 1;
const i64 INF = ~0ULL >> 1;
//*****************************
 
const int maxn = 205, maxm = 10005;
struct Ed {
    int u, v, nx, c, s; Ed() {}
    Ed(int _u, int _v, int _nx, int _c, int _s) :
        u(_u), v(_v), nx(_nx), c(_c), s(_s) {}
} E[maxm << 1];
int G[maxn], cnt;
void addedge(int u, int v, int c, int s) {
    E[cnt] = Ed(u, v, G[u], c, s);
    G[u] = cnt++;
    E[cnt] = Ed(v, u, G[v], 0, -s);
    G[v] = cnt++;
}
 
int s, t, pre[maxn];
int vis[maxn], dis[maxn];
bool spfa() {
    static int que[maxm]; int qh(0), qt(0);
    clr(vis), memset(dis, 0x3f, sizeof(dis));
    vis[que[++qt] = s] = 1, dis[s] = 0;
    while (qh != qt) {
        int x = que[++qh]; vis[x] = 0;
        for (int i = G[x]; i != -1; i = E[i].nx) {
            if (E[i].c && dis[x] + E[i].s < dis[E[i].v]) {
                pre[E[i].v] = i;
                dis[E[i].v] = dis[x] + E[i].s;
                if (!vis[E[i].v]) vis[que[++qt] = E[i].v] = 1;
            }
        }
    }
    return dis[t] != 0x3f3f3f3f;
}
 
map <string, int> M;
string ch[maxn];
int main() {
    int n, m;
    string str;
    cin >> n >> m;
    rep(i, 1, n) {
        cin >> str;
        ch[i] = str;
        M[str] = i;
    }
    s = 0, t = (n << 1) + 1;
    memset(G, -1, sizeof(G));
    addedge(s, 1, 2, -1), addedge(n << 1, t, 2, 0);
    while (m--) {
        int x, y;
        cin >> str; x = M[str];
        cin >> str; y = M[str];
        if (x == 1 || y == n) addedge(x, y + n, 2, -1);
        else addedge(x, y + n, 1, -1);
    }
    REP(i, 2, n) addedge(i + n, i, 1, 0);
    addedge(1 + n, 1, 2, 0), addedge(n + n, n, 2, 0);
    pre[0] = -1;
    int ans(0), f(0);
    while (spfa()) {
        int flow = inf;
        for (int i = pre[t]; i != -1; i = pre[E[i].u])
            flow = min(flow, E[i].c);
        f += flow;
        for (int i = pre[t]; i != -1; i = pre[E[i].u]) {
            E[i].c -= flow, E[i ^ 1].c += flow;
            ans += E[i].s * flow;
        }
    }
    if (f < 2) puts("-1");
    else {
        static int pri[maxn]; int top(0);
        cout << -ans - 2 << endl;
        int k = 1;
        while (1) {
            pri[++top] = k;
            for (int i = G[k]; i != -1; i = E[i].nx) {
                if (E[i].v - n <= k) continue;
                if (E[i ^ 1].c != 0) {
                    E[i].c += 1, E[i ^ 1].c -= 1;
                    k = E[i].v - n;
                    break;
                }
            }
            if (k == n) break;
        }
        k = n + n;
        while (1) {
            pri[++top] = k - n;
            for (int i = G[k]; i != -1; i = E[i].nx) {
                if (E[i].v >= k - n) continue;
                if (E[i].c != 0) {
                    k = E[i].v + n;
                    break;
                }
            }
            if (k == n + 1) break;
        }
        pri[++top] = k - n;
        for (int i = top; i >= 1; i--) cout << ch[pri[i]] << endl;
    }
    return 0;
}