【线性规划和网络流24题】

（1）飞行员配对方案问题：二分图最大匹配。

思路：略。

#include<cstdio>
#include<cstring>
#define MAXN 1010
int cx[MAXN], cy[MAXN];
int first[MAXN], next[MAXN], v[MAXN], e;
bool vis[MAXN];
inline void addEdge(int x, int y) {
    v[e] = y;
    next[e] = first[x];
    first[x] = e++;
}
int path(int x) {
    int i;
    int y;
    for (i = first[x]; i != -1; i = next[i]) {
        y = v[i];
        if (!vis[y]) {
            vis[y] = true;
            if (cy[y] == -1 || path(cy[y])) {
                cx[x] = y;
                cy[y] = x;
                return 1;
            }
        }
    }
    return 0;
}
int main() {
    int n, m;
    int i;
    int x, y;
    int ans;
    while (~scanf("%d%d", &m, &n)) {
        e = 0;
        memset(first, -1, sizeof(first));
        while (scanf("%d%d", &x, &y), x != -1) {
            addEdge(x, y);
        }
        ans = 0;
        memset(cx, -1, sizeof(cx));
        memset(cy, -1, sizeof(cy));
        for (i = 1; i <= m; i++) {
            memset(vis, false, sizeof(vis));
            ans += path(i);
        }
        if (ans) {
            printf("%d\n", ans);
            for (i = 1; i <= m; i++) {
                if (cx[i] != -1) {
                    printf("%d %d\n", i, cx[i]);
                }
            }
        } else {
            puts("No Solution!");
        }
    }
    return 0;
}

（2）太空飞行计划问题：最大权闭合图。

思路：

1。源向实验连边，流量为收益。

2。仪器向汇连边，流量为消耗。

3。实验向仪器连边，流量为无穷。

4。所有实验的收益-最大流=最大收益。

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#include<iostream>
#define MAXL 1010
#define MAXN 100010
#define MAXM 1000010
#define oo 0x7FFFFFFF
using namespace std;
int first[MAXN], next[MAXM], v[MAXM], cost[MAXM], e;
int n;
int src, des;

bool flag;
bool vis[MAXL];
char str[MAXN];
vector<int> g[MAXL];
vector<int> test;
vector<int> app;
int a[MAXL];
inline void addEdge(int x, int y, int val) {
    v[e] = y;
    cost[e] = val;
    next[e] = first[x];
    first[x] = e++;

    v[e] = x;
    cost[e] = 0;
    next[e] = first[y];
    first[y] = e++;
}
int SAP() {
    int pre[MAXN], cur[MAXN], dis[MAXN], gap[MAXN];
    int flow = 0;
    int aug = oo;
    int x, y;
    bool flag;
    for (int i = 0; i < n; i++) {
        cur[i] = first[i];
        gap[i] = dis[i] = 0;
    }
    gap[src] = n;
    x = pre[src] = src;
    while (dis[src] < n) {
        flag = false;
        for (int &j = cur[x]; j != -1; j = next[j]) {
            y = v[j];
            if (cost[j] > 0 && dis[x] == dis[y] + 1) {
                flag = true;
                aug = min(aug, cost[j]);
                pre[y] = x;
                x = y;
                if (x == des) {
                    flow += aug;
                    while (x != src) {
                        x = pre[x];
                        cost[cur[x]] -= aug;
                        cost[cur[x] ^ 1] += aug;
                    }
                    aug = oo;
                }
                break;
            }
        }
        if (flag) {
            continue;
        }
        int tmp = n;
        for (int j = first[x]; j != -1; j = next[j]) {
            y = v[j];
            if (cost[j] > 0 && dis[y] < tmp) {
                tmp = dis[y];
                cur[x] = j;
            }
        }
        if ((--gap[dis[x]]) == 0) {
            break;
        }
        gap[dis[x] = tmp + 1]++;
        x = pre[x];
    }
    return flow;
}
void out(vector<int> res) {
    int i;
    sort(res.begin(), res.end());
    res.resize(unique(res.begin(), res.end()) - res.begin());
    for (i = 0; i < (int) res.size(); i++) {
        if (i) {
            putchar(' ');
        }
        printf("%d", res[i]);
    }
    putchar('\n');
}
void dfs(int x) {
    int i;
    vis[x] = true;
    if (x == des) {
        flag = false;
    }
    for (i = first[x]; i != -1; i = next[i]) {
        if (!vis[v[i]] && cost[i] > 0) {
            dfs(v[i]);
        }
    }
}
int main() {
    int m;
    int i, j, k;
    int len;
    int ans;
    while (~scanf("%d%d", &m, &n)) {
        src = 0;
        des = n + m + 1;
        e = 0;
        memset(first, -1, sizeof(first));
        gets(str);
        for (i = 1; i <= m; i++) {
            g[i].clear();
            gets(str);
            len = strlen(str);
            for (j = 0; j < len; j++) {
                for (; j < len && str[j] == ' '; j++)
                    ;
                if (j < len) {
                    sscanf(str + j, "%d", &k);
                    g[i].push_back(k);
                }
                for (; j < len && isdigit(str[j]); j++)
                    ;
            }
        }
        for (i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
            addEdge(m + i, des, a[i]);
        }
        ans = 0;
        for (i = 1; i <= m; i++) {
            addEdge(src, i, g[i][0]);
            ans += g[i][0];
            for (j = 1; j < (int) g[i].size(); j++) {
                addEdge(i, m + g[i][j], oo);
            }
        }
        n = des + 1;
        ans -= SAP();
        test.clear();
        app.clear();
        for (i = first[src]; i != -1; i = next[i]) {
            k = v[i];
            flag = true;
            memset(vis, false, sizeof(vis));
            dfs(k);
            if (flag) {
                test.push_back(k);
                for (j = 1; j < (int) g[k].size(); j++) {
                    app.push_back(g[k][j]);
                }
            }
        }
        out(test);
        out(app);
        printf("%d\n", ans);
    }
    return 0;
}

 （3）最小路径覆盖问题：有向无环图最小路径覆盖。

思路：

1。当原图没有边，增加一条边，就增加一个匹配，显然少了一条路径。

2。当已经有了一个匹配，增加一条边，不会增加匹配数，路径数需增加1。

#include<cstdio>
#include<cstring>
#include<vector>
#define MAXN 1010
#define MAXM 100010
using namespace std;
int first[MAXN], v[MAXM], next[MAXM], e;
int cx[MAXN], cy[MAXN];
bool vis[MAXN];
vector<int> res;
inline void addEdge(int x, int y) {
    next[e] = first[x];
    v[e] = y;
    first[x] = e++;
}
int path(int x) {
    int i;
    int y;
    for (i = first[x]; i != -1; i = next[i]) {
        y = v[i];
        if (!vis[y]) {
            vis[y] = true;
            if (cy[y] == -1 || path(cy[y])) {
                cx[x] = y;
                cy[y] = x;
                return 1;
            }
        }
    }
    return 0;
}
int Match(int n) {
    int i;
    int ans = 0;
    memset(cx, -1, sizeof(cx));
    memset(cy, -1, sizeof(cy));
    for (i = 1; i <= n; i++) {
        memset(vis, false, sizeof(vis));
        ans += path(i);
    }
    return n - ans;
}
void dfs(int x) {
    vis[x] = true;
    res.push_back(x);
    if (cx[x] != -1) {
        dfs(cx[x]);
    }
}
int main() {
    int n, m;
    int i, j;
    int x, y;
    int ans;
    while (~scanf("%d%d", &n, &m)) {
        e = 0;
        memset(first, -1, sizeof(first));
        for (i = 0; i < m; i++) {
            scanf("%d%d", &x, &y);
            addEdge(x, y);
        }
        ans = Match(n);
        memset(vis, false, sizeof(vis));
        for (i = 1; i <= n; i++) {
            if (!vis[i]) {
                res.clear();
                dfs(i);
                for (j = 0; j < (int) res.size() - 1; j++) {
                    printf("%d ", res[j]);
                }
                printf("%d\n", res[j]);
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

（4）魔术球问题：有向无环图最小路径覆盖。

思路：

1。若x+y为平方数，则x,y'连一条有向边。

2。递增答案，同时增加新的边，更新二分图的交错路。

3。最小路径覆盖=顶点数-二分图最大匹配。

#include<cstdio>
#include<cstring>
#include<vector>
#define MAXN 2010
#define MAXM 200010
using namespace std;
int first[MAXN], next[MAXM], v[MAXM], e;
int cx[MAXN], cy[MAXN];
int nx[MAXN];
bool vis[MAXN];
bool sqr[MAXM];
vector<int> res;
void init() {
    int i;
    memset(sqr, false, sizeof(sqr));
    for (i = 1; i * i < MAXM; i++) {
        sqr[i * i] = true;
    }
}
inline void addEdge(int x, int y) {
    v[e] = y;
    next[e] = first[x];
    first[x] = e++;
}
int path(int x) {
    int i;
    int y;
    for (i = first[x]; i != -1; i = next[i]) {
        y = v[i];
        if (!vis[y]) {
            vis[y] = true;
            if (cy[y] == -1 || path(cy[y])) {
                cx[x] = y;
                cy[y] = x;
                return 1;
            }
        }
    }
    return 0;
}
int cal(int n) {
    int i;
    int ans;
    for (i = 1; i < n; i++) {
        if (sqr[i + n]) {
            addEdge(i, n);
        }
    }
    ans = 0;
    for (i = 1; i <= n; i++) {
        if (cx[i] == -1) {
            memset(vis, false, sizeof(vis));
            ans += path(i);
        } else {
            ans++;
        }
    }
    return n - ans;
}
void dfs(int x) {
    vis[x] = true;
    res.push_back(x);
    if (nx[x] != -1) {
        dfs(nx[x]);
    }
}
int main() {
    int n;
    int i, j;
    init();
    while (~scanf("%d", &n)) {
        e = 0;
        memset(first, -1, sizeof(first));
        memset(cx, -1, sizeof(cx));
        memset(cy, -1, sizeof(cy));
        for (i = 1; cal(i) <= n; i++) {
            memcpy(nx, cx, sizeof(nx));
        }
        n = i - 1;
        printf("%d\n", n);
        memset(vis, false, sizeof(vis));
        for (i = 1; i <= n; i++) {
            if (!vis[i]) {
                res.clear();
                dfs(i);
                for (j = 0; j < (int) res.size() - 1; j++) {
                    printf("%d ", res[j]);
                }
                printf("%d\n", res[j]);
            }
        }
    }
    return 0;
}

（5）圆桌问题：二分图多重匹配。

思路：

1。从源点向每个单位连边，流量为单位人数。

2。从每个圆桌向汇点连边，流量为圆桌人数。

3。每个单位向每个圆桌都连边，流量为1。

4。求最大流。

#include<cstdio>
#include<cstring>
#include<vector>
#define MAXN 1010
#define MAXM 1000010
#define oo 0x7FFFFFFF
using namespace std;
int first[MAXN], next[MAXM], v[MAXM], cost[MAXM], e;
int n;
int src, des;
inline void addEdge(int x, int y, int val) {
    v[e] = y;
    cost[e] = val;
    next[e] = first[x];
    first[x] = e++;

    v[e] = x;
    cost[e] = 0;
    next[e] = first[y];
    first[y] = e++;
}
int SAP() {
    int pre[MAXN], cur[MAXN], dis[MAXN], gap[MAXN];
    int flow = 0;
    int aug = oo;
    int x, y;
    bool flag;
    for (int i = 0; i < n; i++) {
        cur[i] = first[i];
        gap[i] = dis[i] = 0;
    }
    gap[src] = n;
    x = pre[src] = src;
    while (dis[src] < n) {
        flag = false;
        for (int &j = cur[x]; j != -1; j = next[j]) {
            y = v[j];
            if (cost[j] > 0 && dis[x] == dis[y] + 1) {
                flag = true;
                aug = min(aug, cost[j]);
                pre[y] = x;
                x = y;
                if (x == des) {
                    flow += aug;
                    while (x != src) {
                        x = pre[x];
                        cost[cur[x]] -= aug;
                        cost[cur[x] ^ 1] += aug;
                    }
                    aug = oo;
                }
                break;
            }
        }
        if (flag) {
            continue;
        }
        int tmp = n;
        for (int j = first[x]; j != -1; j = next[j]) {
            y = v[j];
            if (cost[j] > 0 && dis[y] < tmp) {
                tmp = dis[y];
                cur[x] = j;
            }
        }
        if ((--gap[dis[x]]) == 0) {
            break;
        }
        gap[dis[x] = tmp + 1]++;
        x = pre[x];
    }
    return flow;
}
int main() {
    int m;
    int i, j;
    int tot;
    vector<int> res[MAXN];
    scanf("%d%d", &m, &n);
    src = 0;
    des = n + m + 1;
    e = 0;
    memset(first, -1, sizeof(first));
    tot = 0;
    for (i = 1; i <= m; i++) {
        scanf("%d", &j);
        addEdge(src, i, j);
        tot += j;
    }
    for (i = 1; i <= n; i++) {
        scanf("%d", &j);
        addEdge(m + i, des, j);
    }
    for (i = 1; i <= m; i++) {
        for (j = m + 1; j <= n + m; j++) {
            addEdge(i, j, 1);
        }
    }
    n = des + 1;
    for (i = 0; i < MAXN; i++) {
        res[i].clear();
    }
    if (tot == SAP()) {
        puts("1");
        for (i = first[src]; i != -1; i = next[i]) {
            for (j = first[v[i]]; j != -1; j = next[j]) {
                if (cost[j] == 0) {
                    res[v[i]].push_back(v[j] - m);
                }
            }
        }
        for (i = 1; i <= m; i++) {
            for (j = 0; j < (int) res[i].size() - 1; j++) {
                printf("%d ", res[i][j]);
            }
            printf("%d\n", res[i][j]);
        }
    } else {
        puts("0");
    }
    return 0;
}

（6）最长递增子序列问题：最多不相交路径。

思路：

1。对于第一问：dp即可。

2。每个点取的次数有要求，所以需要拆点，限制流量。

3。控制最长递增子序列，要从dp转移来连边。

 题目描述有错：应是最长非降子序列，而不是严格递增的。

#include<cstdio>
#include<cstring>
#include<vector>
#define MAXN 10010
#define MAXM 1000010
#define oo 123456789
using namespace std;
int first[MAXN], next[MAXM], v[MAXM], cost[MAXM], e;
int n;
int src, des;

int dp[MAXN];
int arr[MAXN];
inline void addEdge(int x, int y, int val) {
    v[e] = y;
    cost[e] = val;
    next[e] = first[x];
    first[x] = e++;

    v[e] = x;
    cost[e] = 0;
    next[e] = first[y];
    first[y] = e++;
}
int SAP() {
    int pre[MAXN], cur[MAXN], dis[MAXN], gap[MAXN];
    int flow = 0;
    int aug = oo;
    int x, y;
    bool flag;
    for (int i = 0; i < n; i++) {
        cur[i] = first[i];
        gap[i] = dis[i] = 0;
    }
    gap[src] = n;
    x = pre[src] = src;
    while (dis[src] < n) {
        flag = false;
        for (int &j = cur[x]; j != -1; j = next[j]) {
            y = v[j];
            if (cost[j] > 0 && dis[x] == dis[y] + 1) {
                flag = true;
                aug = min(aug, cost[j]);
                pre[y] = x;
                x = y;
                if (x == des) {
                    flow = min(flow + aug, oo);
                    while (x != src) {
                        x = pre[x];
                        cost[cur[x]] -= aug;
                        cost[cur[x] ^ 1] += aug;
                    }
                    aug = oo;
                }
                break;
            }
        }
        if (flag) {
            continue;
        }
        int tmp = n;
        for (int j = first[x]; j != -1; j = next[j]) {
            y = v[j];
            if (cost[j] > 0 && dis[y] < tmp) {
                tmp = dis[y];
                cur[x] = j;
            }
        }
        if ((--gap[dis[x]]) == 0) {
            break;
        }
        gap[dis[x] = tmp + 1]++;
        x = pre[x];
    }
    return flow;
}
int getIndex(int x) {
    return 2 * x - 1;
}
void cal(int len, int val) {
    int i, j;
    int tmp;
    int ans;
    e = 0;
    memset(first, -1, sizeof(first));
    src = 0;
    des = 2 * n + 1;
    for (i = 1; i <= n; i++) {
        if (i == 1 || i == n) {
            addEdge(getIndex(i), getIndex(i) + 1, val);
        } else {
            addEdge(getIndex(i), getIndex(i) + 1, 1);
        }
    }
    for (i = 1; i <= n; i++) {
        if (dp[i] == 1) {
            addEdge(src, getIndex(i), oo);
        }
        if (dp[i] == len) {
            addEdge(getIndex(i) + 1, des, oo);
        }
    }
    for (i = 1; i <= n; i++) {
        for (j = 1; j < i; j++) {
            if (arr[i] >= arr[j] && dp[i] == dp[j] + 1) {
                addEdge(getIndex(j) + 1, getIndex(i), 1);
            }
        }
    }
    tmp = n;
    n = des + 1;
    ans = SAP();
    n = tmp;
    if (ans == oo) {
        ans = n;
    }
    printf("%d\n", ans);
}
int main() {
    int i, j;
    int ans;
    while (~scanf("%d", &n)) {
        for (i = 1; i <= n; i++) {
            scanf("%d", &arr[i]);
            dp[i] = 1;
        }
        for (i = 1; i <= n; i++) {
            for (j = 1; j < i; j++) {
                if (arr[i] >= arr[j]) {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
        }
        ans = 0;
        for (i = 1; i <= n; i++) {
            ans = max(ans, dp[i]);
        }
        printf("%d\n", ans);
        cal(ans, 1);
        cal(ans, oo);
    }
    return 0;
}

（7）试题库问题：二分图多重匹配。

思路：

1。从源点向每道试题连边，流量为1。

2。从每个类型向汇点连边，流量为每个类型所需要的题数。

3。每个试题向所属的类型都连边，流量为1。

4。求最大流。

#include<cstdio>
#include<cstring>
#include<vector>
#define MAXN 1010
#define MAXM 1000010
#define oo 0x7FFFFFFF
using namespace std;
int first[MAXN], next[MAXM], v[MAXM], cost[MAXM], e;
int n;
int src, des;
inline void addEdge(int x, int y, int val) {
    v[e] = y;
    cost[e] = val;
    next[e] = first[x];
    first[x] = e++;

    v[e] = x;
    cost[e] = 0;
    next[e] = first[y];
    first[y] = e++;
}
int SAP() {
    int pre[MAXN], cur[MAXN], dis[MAXN], gap[MAXN];
    int flow = 0;
    int aug = oo;
    int x, y;
    bool flag;
    for (int i = 0; i < n; i++) {
        cur[i] = first[i];
        gap[i] = dis[i] = 0;
    }
    gap[src] = n;
    x = pre[src] = src;
    while (dis[src] < n) {
        flag = false;
        for (int &j = cur[x]; j != -1; j = next[j]) {
            y = v[j];
            if (cost[j] > 0 && dis[x] == dis[y] + 1) {
                flag = true;
                aug = min(aug, cost[j]);
                pre[y] = x;
                x = y;
                if (x == des) {
                    flow += aug;
                    while (x != src) {
                        x = pre[x];
                        cost[cur[x]] -= aug;
                        cost[cur[x] ^ 1] += aug;
                    }
                    aug = oo;
                }
                break;
            }
        }
        if (flag) {
            continue;
        }
        int tmp = n;
        for (int j = first[x]; j != -1; j = next[j]) {
            y = v[j];
            if (cost[j] > 0 && dis[y] < tmp) {
                tmp = dis[y];
                cur[x] = j;
            }
        }
        if ((--gap[dis[x]]) == 0) {
            break;
        }
        gap[dis[x] = tmp + 1]++;
        x = pre[x];
    }
    return flow;
}
int main() {
    int m;
    int i, j, k;
    int tot;
    vector<int> res[MAXN];
    while (~scanf("%d%d", &m, &n)) {
        tot = 0;
        src = 0;
        des = m + n + 1;
        e = 0;
        memset(first, -1, sizeof(first));
        for (i = 1; i <= m; i++) {
            scanf("%d", &j);
            addEdge(n + i, des, j);
            tot += j;
        }
        for (i = 1; i <= n; i++) {
            scanf("%d", &j);
            addEdge(src, i, 1);
            while (j--) {
                scanf("%d", &k);
                addEdge(i, n + k, 1);
            }
        }
        k = n;
        n = des + 1;
        if (SAP() == tot) {
            for (i = 0; i < MAXN; i++) {
                res[i].clear();
            }
            for (i = first[src]; i != -1; i = next[i]) {
                for (j = first[v[i]]; j != -1; j = next[j]) {
                    if (cost[j] == 0) {
                        if (v[j] > k)
                            res[v[j] - k].push_back(v[i]);
                    }
                }
            }
            for (i = 1; i <= m; i++) {
                printf("%d:", i);
                for (j = 0; j < (int) res[i].size(); j++) {
                    printf(" %d", res[i][j]);
                }
                putchar('\n');
            }
        } else {
            puts("No Solution!");
        }
    }
    return 0;
}

（9）方格取数问题：二分图点权最大独立集。

思路：

1。方格黑白染色。源向黑格连边，流量为点权；白格向汇连边，流量为点权；黑格与相邻的白格连边，流量为oo。因此，最小割是简单割，即最小权覆盖集。

2。由于独立集与覆盖集是互补的，所以最小权覆盖集+最大权独立集=总权值。

#include<cstdio>
#include<cstring>
#include<vector>
#define MAXL 210
#define MAXN 100010
#define MAXM 1000010
#define oo 123456789
using namespace std;
int first[MAXN], next[MAXM], v[MAXM], cost[MAXM], e;
int n, m;
int src, des;
int arr[MAXL][MAXL];
int go[4][2] = { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };
inline void addEdge(int x, int y, int val) {
    v[e] = y;
    cost[e] = val;
    next[e] = first[x];
    first[x] = e++;

    v[e] = x;
    cost[e] = 0;
    next[e] = first[y];
    first[y] = e++;
}
int SAP() {
    int pre[MAXN], cur[MAXN], dis[MAXN], gap[MAXN];
    int flow = 0;
    int aug = oo;
    int x, y;
    bool flag;
    for (int i = 0; i < n; i++) {
        cur[i] = first[i];
        gap[i] = dis[i] = 0;
    }
    gap[src] = n;
    x = pre[src] = src;
    while (dis[src] < n) {
        flag = false;
        for (int &j = cur[x]; j != -1; j = next[j]) {
            y = v[j];
            if (cost[j] > 0 && dis[x] == dis[y] + 1) {
                flag = true;
                aug = min(aug, cost[j]);
                pre[y] = x;
                x = y;
                if (x == des) {
                    flow += aug;
                    while (x != src) {
                        x = pre[x];
                        cost[cur[x]] -= aug;
                        cost[cur[x] ^ 1] += aug;
                    }
                    aug = oo;
                }
                break;
            }
        }
        if (flag) {
            continue;
        }
        int tmp = n;
        for (int j = first[x]; j != -1; j = next[j]) {
            y = v[j];
            if (cost[j] > 0 && dis[y] < tmp) {
                tmp = dis[y];
                cur[x] = j;
            }
        }
        if ((--gap[dis[x]]) == 0) {
            break;
        }
        gap[dis[x] = tmp + 1]++;
        x = pre[x];
    }
    return flow;
}
int getIndex(int x, int y) {
    return (x - 1) * m + y;
}
int main() {
    int i, j, k;
    int x, y;
    int ans;
    while (~scanf("%d%d", &n, &m)) {
        src = 0;
        des = m * n + 1;
        e = 0;
        memset(first, -1, sizeof(first));
        ans = 0;
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                scanf("%d", &arr[i][j]);
                ans += arr[i][j];
                if ((i + j) & 1) {
                    addEdge(src, getIndex(i, j), arr[i][j]);
                    for (k = 0; k < 4; k++) {
                        x = i + go[k][0];
                        y = j + go[k][1];
                        if (x > 0 && x <= n && y > 0 && y <= m) {
                            addEdge(getIndex(i, j), getIndex(x, y), oo);
                        }
                    }
                } else {
                    addEdge(getIndex(i, j), des, arr[i][j]);
                }
            }
        }
        n = des + 1;
        ans = ans - SAP();
        printf("%d\n", ans);
    }
    return 0;
}

（10）餐巾计划问题：线性规划网络优化。

思路：

1。由于第i天的新餐巾可以由i-m天的脏餐巾洗来，因此考虑按天数建模。

2。每天的餐巾有新旧之分，则考虑拆点，每天的新餐巾数量和每天的旧餐巾数量。

3。新餐巾可以直接买来。

4。新餐巾可以由前些天的旧餐巾洗来。

5。旧餐巾可以由上一天的旧餐巾积累而来。

6。求最小费用最大流。

#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
#define oo 123456
#define MAXN 100010
#define MAXM 1000010
using namespace std;
int V, e;
int src, des;
int lk[MAXN], father[MAXN];
int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
int dis[MAXN];
bool inq[MAXN];

int arr[MAXN];
void addEdge(int x, int y, int f, int c) {
    v[e] = y;
    flow[e] = f;
    cost[e] = c;
    next[e] = first[x];
    first[x] = e++;

    v[e] = x;
    flow[e] = 0;
    cost[e] = -c;
    next[e] = first[y];
    first[y] = e++;
}
bool SPFA() {
    int i, u;
    deque<int> q;
    memset(inq, false, sizeof(inq));
    for (i = 0; i <= V; i++) {
        dis[i] = oo;
    }
    dis[src] = 0;
    q.push_back(src);
    inq[src] = true;
    while (!q.empty()) {
        u = q.front();
        q.pop_front();
        inq[u] = false;
        for (i = first[u]; i != -1; i = next[i]) {
            if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
                dis[v[i]] = dis[u] + cost[i];
                father[v[i]] = u;
                lk[v[i]] = i;
                if (!inq[v[i]]) {
                    inq[v[i]] = true;
                    if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
                        q.push_front(v[i]);
                    } else {
                        q.push_back(v[i]);
                    }
                }
            }
        }
    }
    return dis[des] != oo;
}
int MinCostMaxFlow() {
    int u;
    int ans;
    int tmp;
    for (ans = 0; SPFA();) {
        tmp = oo;
        for (u = des; u; u = father[u]) {
            tmp = min(tmp, flow[lk[u]]);
        }
        for (u = des; u; u = father[u]) {
            flow[lk[u]] -= tmp;
            flow[lk[u] ^ 1] += tmp;
        }
        ans += tmp * dis[des];
    }
    return ans;
}
int main() {
    int i;
    int n;
    int buy, fastCost, slowCost, slowDay, fastDay;
    while (~scanf("%d%d%d%d%d%d", &n, &buy, &fastDay, &fastCost, &slowDay,
            &slowCost)) {
        e = 0;
        src = 0;
        des = n + n + 1;
        V = des;
        memset(first, -1, sizeof(first));
        for (i = 1; i <= n; i++) {
            scanf("%d", &arr[i]);
            addEdge(2 * i, des, arr[i], 0);
            addEdge(src, 2 * i, arr[i], buy);
            addEdge(src, 2 * i - 1, arr[i], 0);
        }
        for (i = 2; i <= n; i++) {
            addEdge(2 * (i - 1) - 1, 2 * i - 1, oo, 0);
        }
        for (i = 1; i <= n; i++) {
            if (i + fastDay <= n) {
                addEdge(2 * i - 1, 2 * (i + fastDay), oo, fastCost);
            }
            if (i + slowDay <= n) {
                addEdge(2 * i - 1, 2 * (i + slowDay), oo, slowCost);
            }
        }
        for (i = 1; i <= n; i++) {
            addEdge(src, i, oo, buy);
        }
        printf("%d\n", MinCostMaxFlow());
    }
    return 0;
}

（11）航空路线问题：最长不相交路径。

思路：

1。从东->西，再从西->东。相当于从东->西两条不相交的路径。

2。要求路径最长，则考虑最大费用最大流。

#include<iostream>
#include<algorithm>
#include<string>
#include<cstring>
#include<queue>
#include<vector>
#include<map>
#define oo 0x7FFFFFFF
#define MAXL 110
#define MAXN 10010
#define MAXM 1000010
using namespace std;
int V, n, m, e;
int src, des;
int lk[MAXN], father[MAXN];
int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
int dis[MAXN];
bool inq[MAXN];

vector<string> city;
map<string, int> mymap;
vector<int> res;
bool g[MAXL][MAXL];
bool vis[MAXN];
void addEdge(int x, int y, int f, int c) {
    v[e] = y;
    flow[e] = f;
    cost[e] = c;
    next[e] = first[x];
    first[x] = e++;

    v[e] = x;
    flow[e] = 0;
    cost[e] = -c;
    next[e] = first[y];
    first[y] = e++;
}
bool SPFA() {
    int i, u;
    deque<int> q;
    memset(inq, false, sizeof(inq));
    for (i = 0; i <= V; i++) {
        dis[i] = oo;
    }
    dis[src] = 0;
    q.push_back(src);
    inq[src] = true;
    while (!q.empty()) {
        u = q.front();
        q.pop_front();
        inq[u] = false;
        for (i = first[u]; i != -1; i = next[i]) {
            if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
                dis[v[i]] = dis[u] + cost[i];
                father[v[i]] = u;
                lk[v[i]] = i;
                if (!inq[v[i]]) {
                    inq[v[i]] = true;
                    if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
                        q.push_front(v[i]);
                    } else {
                        q.push_back(v[i]);
                    }
                }
            }
        }
    }
    return dis[des] != oo;
}
int MinCostMaxFlow(int tot) {
    int u;
    int ans;
    int tmp;
    int flux;
    for (ans = flux = 0; SPFA();) {
        tmp = oo;
        for (u = des; u; u = father[u]) {
            tmp = min(tmp, flow[lk[u]]);
        }
        for (u = des; u; u = father[u]) {
            flow[lk[u]] -= tmp;
            flow[lk[u] ^ 1] += tmp;
        }
        ans += tmp * dis[des];
        flux += tmp;
    }
    if (flux != tot) {
        return oo;
    } else {
        return ans;
    }
}
void dfs(int x) {
    vis[x] = true;
    int i;
    res.push_back(x >> 1);
    for (i = first[x]; i != -1; i = next[i]) {
        if ((i & 1) == 0 && flow[i] == 0 && !vis[v[i]]) {
            dfs(v[i]);
        }
    }
}
int main() {
    int i, j;
    string str1, str2;
    int ans;
    bool flag;
    while (cin >> n >> m) {
        memset(g, false, sizeof(g));
        src = 0;
        des = n + n - 1;
        V = des;
        e = 0;
        memset(first, -1, sizeof(first));
        city.clear();
        mymap.clear();
        addEdge(0, 1, 2, 0);
        addEdge(des - 1, des, 2, 0);
        for (i = 2; i < des - 1; i += 2) {
            addEdge(i, i + 1, 1, 0);
        }
        for (i = 0; i < n; i++) {
            cin >> str1;
            city.push_back(str1);
            mymap[str1] = i << 1;
        }
        while (m--) {
            cin >> str1 >> str2;
            i = mymap[str1];
            j = mymap[str2];
            if (i > j) {
                swap(i, j);
            }
            addEdge(i ^ 1, j, 1, -1);
            g[i / 2][j / 2] = g[j / 2][i / 2] = true;
        }
        ans = MinCostMaxFlow(2);
        if (ans == oo) {
            if (g[0][n - 1]) {
                cout << 2 << endl;
                cout << city[0] << endl;
                cout << city[n - 1] << endl;
                cout << city[0] << endl;
            } else {
                cout << "No Solution!" << endl;
            }
        } else {
            cout << -ans << endl;
            memset(vis, false, sizeof(vis));
            flag = false;
            cout << city[0] << endl;
            for (i = first[1]; i != -1; i = next[i]) {
                if ((i & 1) == 0 && flow[i] == 0 && !vis[v[i]]) {
                    res.clear();
                    dfs(v[i]);
                    if (flag) {
                        reverse(res.begin(), res.end());
                    } else {
                        flag = true;
                    }
                    res.resize(unique(res.begin(), res.end()) - res.begin());
                    for (j = 0; j < (int) res.size(); j++) {
                        cout << city[res[j]] << endl;
                    }
                }
            }
            cout << city[0] << endl;
        }
    }
    return 0;
}

（12）软件补丁问题：最小转移代价。

思路：

1。只有20个补丁，很容易想到状态压缩。

2。最多(1<<20)个状态，一个状态到另一个状态间有一个花费。

3。求最短花费，就是最短路了。

题目描述有错：第二个字符串中'-'是f1的，'+'是f2的。

#include<cstdio>
#include<cstring>
#include<queue>
#define oo 0x7FFFFFFF
#define MAXN 1<<20
#define MAXM 110
using namespace std;
int dis[MAXN];
bool inq[MAXN];
struct patch {
    int b1, b2;
    int f1, f2;
    int cost;
} p[MAXM];
int n, m;
void update(char str[], int &x, int &y) {
    int i;
    x = y = 0;
    for (i = 0; str[i]; i++) {
        if (str[i] == '+') {
            x |= 1 << i;
        } else if (str[i] == '-') {
            y |= 1 << i;
        }
    }
}
void spfa(int src) {
    int i;
    int x, y;
    deque<int> q;
    memset(inq, false, sizeof(inq));
    for (i = 0; i < (1 << n); i++) {
        dis[i] = oo;
    }
    dis[src] = 0;
    q.push_back(src);
    while (!q.empty()) {
        x = q.front();
        q.pop_front();
        inq[x] = false;
        for (i = 0; i < m; i++) {
            if ((x | p[i].b1) == x && (x & p[i].b2) == 0) {
                y = x & (~p[i].f1);
                y |= p[i].f2;
                if (dis[y] > dis[x] + p[i].cost) {
                    dis[y] = dis[x] + p[i].cost;
                    if (!inq[y]) {
                        if (!q.empty() && dis[y] <= dis[q.front()]) {
                            q.push_front(y);
                        } else {
                            q.push_back(y);
                        }
                        inq[y] = true;
                    }
                }
            }
        }
    }
}
int main() {
    int i;
    char a[MAXM], b[MAXM];
    while (~scanf("%d%d", &n, &m)) {
        for (i = 0; i < m; i++) {
            scanf("%d %s %s", &p[i].cost, a, b);
            update(a, p[i].b1, p[i].b2);
            update(b, p[i].f2, p[i].f1);
        }
        spfa((1 << n) - 1);
        if (dis[0] == oo) {
            puts("0");
        } else {
            printf("%d\n", dis[0]);
        }
    }
    return 0;
}

（13）星际转移问题：网络判定。

思路：

1。枚举天数。随着天数的增加，不断增加点和边。

2。判最大流是否大于等于K。

#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#define oo 123456
#define MAXN 1010
#define MAXM 100010
using namespace std;
int src;
int des;
int V;
int ans;
vector<int> path[MAXN];
vector<int> cap;
vector<int> ind[MAXN];
vector<int> pos[MAXN];
int G[MAXN][MAXN];
int first[MAXN], next[MAXN], v[MAXN], e;
bool vis[MAXN];
int BFS() {
    queue<int> q;
    int tmp, i, u, v, head, p[MAXN];
    memset(p, -1, sizeof(p));
    p[src] = src;
    q.push(src);
    while (!q.empty()) {
        head = q.front();
        q.pop();
        for (i = 1; i <= V; i++) {
            if (G[head][i] > 0 && p[i] == -1) {
                p[i] = head;
                q.push(i);
            }
        }
    }
    if (p[des] == -1)
        return 0;
    for (tmp = oo, u = des; p[u] != u;) {
        v = u;
        u = p[u];
        tmp = min(tmp, G[u][v]);
    }
    for (u = des; p[u] != u;) {
        v = u;
        u = p[u];
        G[u][v] -= tmp;
        G[v][u] += tmp;
    }
    return tmp;
}
void EdmondsKarp() {
    int tmp;
    for (; (tmp = BFS()); ans += tmp)
        ;
}
inline void addEdge(int x, int y) {
    next[e] = first[x];
    v[e] = y;
    first[x] = e++;
}
bool dfs(int x) {
    int i;
    int y;
    vis[x] = true;
    for (i = first[x]; i != -1; i = next[i]) {
        y = v[i];
        if (!vis[y]) {
            if (dfs(y)) {
                return true;
            }
        }
    }
    return x == des;
}
int main() {
    int n, m, k;
    int i, j, t;
    int tmp;
    int day;
    int tot;
    while (~scanf("%d%d%d", &n, &m, &k)) {
        cap.clear();
        for (i = 0; i < m; i++) {
            scanf("%d%d", &j, &tmp);
            cap.push_back(j);
            while (tmp--) {
                scanf("%d", &j);
                j += 3;
                path[i].push_back(j);
            }
        }
        src = 3;
        des = 2;
        e = 0;
        memset(first, -1, sizeof(first));
        memset(vis, false, sizeof(vis));
        for (i = 0; i < m; i++) {
            for (j = 0; j < (int) path[i].size(); j++) {
                addEdge(path[i][j], path[i][(j + 1) % path[i].size()]);
                addEdge(path[i][j + 1] % path[i].size(), path[i][j]);
            }
        }
        if (dfs(src)) {
            ans = 0;
            memset(G, 0, sizeof(G));
            src = 0;
            des = 1;
            tot = 2;
            for (i = 0; i < m; i++) {
                ind[i].clear();
                pos[i].clear();
                ind[i].push_back(tot++);
                pos[i].push_back(path[i][0]);
            }
            for (i = 0; i < m; i++) {
                if (pos[i][0] == 3) {
                    G[src][ind[i][0]] = oo;
                } else if (pos[i][0] == 2) {
                    G[ind[i][0]][des] = oo;
                }
            }
            for (day = 1; ans < k; day++) {
                for (i = 0; i < m; i++) {
                    ind[i].push_back(tot++);
                    pos[i].push_back(path[i][day % (path[i].size())]);
                    G[ind[i][day - 1]][ind[i][day]] = cap[i];
                }
                for (i = 0; i < m; i++) {
                    for (j = 0; j < m; j++) {
                        for (t = 0; t <= day; t++) {
                            if (pos[j][t] == pos[i][day]) {
                                G[ind[j][t]][ind[i][day]] = oo;
                            }
                        }
                    }
                }
                for (i = 0; i < m; i++) {
                    if (pos[i][day] == 3) {
                        G[src][ind[i][day]] = oo;
                    } else if (pos[i][day] == 2) {
                        G[ind[i][day]][des] = oo;
                    }
                }
                V = tot;
                EdmondsKarp();
            }
            printf("%d\n", day - 1);
        } else {
            puts("0");
        }
    }
    return 0;
}

（14）孤岛营救问题：分层图最短路径。 

 思路：

对钥匙种类状态压缩。dp[i][j][k]表示在(i,j)，钥匙种类为k的最短路。

#include<cstdio>
#include<cstring>
#include<queue>
#define MAXN 11
#define oo 123456789
using namespace std;
int dp[MAXN][MAXN][1 << MAXN];
int g[MAXN][MAXN][MAXN][MAXN];
int mp[MAXN][MAXN];
int go[4][2] = { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };
struct node {
    int x;
    int y;
    int key;
    int dis;
};
int n, m, p;
inline bool canMove(int x0, int y0, int x1, int y1, int key) {
    int tmp = g[x0][y0][x1][y1];
    if (tmp == -1) {
        return true;
    } else if (tmp == 0) {
        return false;
    } else if (key & (1 << (tmp - 1))) {
        return true;
    } else {
        return false;
    }
}
int bfs() {
    node head, tmp;
    queue<node> q;
    int ans;
    int i, j, k;
    for (i = 1; i <= n; i++) {
        for (j = 1; j <= m; j++) {
            for (k = 0; k < (1 << p); k++)
                dp[i][j][k] = oo;
        }
    }
    head.x = head.y = 1;
    head.key = 0;
    head.dis = 0;
    q.push(head);
    while (!q.empty()) {
        head = q.front();
        q.pop();
        for (i = 0; i < 4; i++) {
            tmp.x = head.x + go[i][0];
            tmp.y = head.y + go[i][1];
            if (tmp.x > 0 && tmp.x <= n && tmp.y > 0 && tmp.y <= m
                    && canMove(head.x, head.y, tmp.x, tmp.y, head.key)) {
                tmp.dis = head.dis + 1;
                tmp.key = head.key;
                tmp.key |= mp[tmp.x][tmp.y];
                if (tmp.dis < dp[tmp.x][tmp.y][tmp.key]) {
                    dp[tmp.x][tmp.y][tmp.key] = tmp.dis;
                    q.push(tmp);
                }
            }
        }
    }
    ans = oo;
    for (i = 0; i < (1 << p); i++) {
        ans = min(ans, dp[n][m][i]);
    }
    if (ans == oo) {
        return -1;
    } else {
        return ans;
    }
}
int main() {
    int i, j;
    int x0, y0, x1, y1;
    while (~scanf("%d%d%d", &n, &m, &p)) {
        memset(g, -1, sizeof(g));
        memset(mp, 0, sizeof(mp));
        scanf("%d", &i);
        while (i--) {
            scanf("%d%d%d%d%d", &x0, &y0, &x1, &y1, &j);
            g[x0][y0][x1][y1] = g[x1][y1][x0][y0] = j;
        }
        scanf("%d", &i);
        while (i--) {
            scanf("%d%d%d", &x0, &y0, &j);
            mp[x0][y0] |= 1 << (j - 1);
        }
        printf("%d\n", bfs());
    }
    return 0;
}

（15）汽车加油行驶问题：分层图最短路径。 

 思路：

dp[i][j][k]表示在(i,j)，油量为k的最少花费。

#include<cstdio>
#include<cstring>
#include<queue>
#define MAXN 110
#define MAXM 15
#define oo 123456789
using namespace std;
int dp[MAXN][MAXN][MAXM];
int n, k, a, b, c;
int g[MAXN][MAXN];
struct node {
    int x;
    int y;
    int gass;
    int cost;
};
int go[4][2] = { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };
int spfa() {
    int i, j, l;
    int ans;
    node head, tmp;
    queue<node> q;
    for (i = 0; i <= n; i++) {
        for (j = 0; j <= n; j++) {
            for (l = 0; l <= k; l++) {
                dp[i][j][l] = oo;
            }
        }
    }
    dp[1][1][k] = 0;
    head.x = head.y = 1;
    head.gass = k;
    head.cost = 0;
    q.push(head);
    while (!q.empty()) {
        head = q.front();
        q.pop();
        if (head.gass == 0) {
            continue;
        }
        for (i = 0; i < 4; i++) {
            tmp.x = head.x + go[i][0];
            tmp.y = head.y + go[i][1];
            if (tmp.x > 0 && tmp.x <= n && tmp.y > 0 && tmp.y <= n) {
                tmp.gass = head.gass - 1;
                tmp.cost = head.cost;
                if (tmp.x < head.x || tmp.y < head.y) {
                    tmp.cost += b;
                }
                if (g[tmp.x][tmp.y]) {
                    tmp.gass = k;
                    tmp.cost += a;
                }
                if (tmp.cost < dp[tmp.x][tmp.y][tmp.gass]) {
                    dp[tmp.x][tmp.y][tmp.gass] = tmp.cost;
                    q.push(tmp);
                }
                if (!g[tmp.x][tmp.y]) {
                    tmp.gass = k;
                    tmp.cost += a + c;
                    if (tmp.cost < dp[tmp.x][tmp.y][tmp.gass]) {
                        dp[tmp.x][tmp.y][tmp.gass] = tmp.cost;
                        q.push(tmp);
                    }
                }
            }
        }
    }
    ans = oo;
    for (i = 0; i <= k; i++) {
        ans = min(ans, dp[n][n][i]);
    }
    return ans;
}
int main() {
    int i, j;
    while (~scanf("%d%d%d%d%d", &n, &k, &a, &b, &c)) {
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= n; j++) {
                scanf("%d", &g[i][j]);
            }
        }
        printf("%d\n", spfa());
    }
    return 0;
}

（16）数字梯形问题：最大权不相交路径。

 思路：

规则1：拆点，点与点之间流量都为1。

规则2：不拆点，点与点流量为1。

规则3：不拆点，点与点流量为无穷。

添加源点，汇点。求最小费用最大流。

#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#define oo 0x7FFFFFFF
#define MAXN 10010
#define MAXM 1000010
using namespace std;
int V, n, m, e;
int src, des;
int link[MAXN], father[MAXN];
int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
int dis[MAXN];
bool inq[MAXN];

vector<int> arr[MAXN];
vector<int> pos[MAXN];
int size;
void addEdge(int x, int y, int f, int c) {
    v[e] = y;
    flow[e] = f;
    cost[e] = c;
    next[e] = first[x];
    first[x] = e++;

    v[e] = x;
    flow[e] = 0;
    cost[e] = -c;
    next[e] = first[y];
    first[y] = e++;
}
bool SPFA() {
    int i, u;
    deque<int> q;
    memset(inq, false, sizeof(inq));
    for (i = 0; i <= V; i++) {
        dis[i] = oo;
    }
    dis[src] = 0;
    q.push_back(src);
    inq[src] = true;
    while (!q.empty()) {
        u = q.front();
        q.pop_front();
        inq[u] = false;
        for (i = first[u]; i != -1; i = next[i]) {
            if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
                dis[v[i]] = dis[u] + cost[i];
                father[v[i]] = u;
                link[v[i]] = i;
                if (!inq[v[i]]) {
                    inq[v[i]] = true;
                    if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
                        q.push_front(v[i]);
                    } else {
                        q.push_back(v[i]);
                    }
                }
            }
        }
    }
    return dis[des] != oo;
}
int MinCostMaxFlow() {
    int u;
    int ans;
    int tmp;
    for (ans = 0; SPFA();) {
        tmp = oo;
        for (u = des; u; u = father[u]) {
            tmp = min(tmp, flow[link[u]]);
        }
        for (u = des; u; u = father[u]) {
            flow[link[u]] -= tmp;
            flow[link[u] ^ 1] += tmp;
        }
        ans += tmp * dis[des];
    }
    return ans;
}
int getIndex(int x) {
    return 2 * x - 1;
}
void rule1() {
    int i, j;
    e = 0;
    src = 0;
    des = 2 * size + 1;
    V = des;
    memset(first, -1, sizeof(first));
    for (i = 1; i <= size; i++) {
        addEdge(getIndex(i), getIndex(i) + 1, 1, 0);
    }
    for (i = 0; i < (int) arr[1].size(); i++) {
        addEdge(src, getIndex(pos[1][i]), 1, -arr[1][i]);
    }
    for (i = 1; i < n; i++) {
        for (j = 0; j < (int) arr[i].size(); j++) {
            addEdge(getIndex(pos[i][j]) + 1, getIndex(pos[i + 1][j]), 1,
                    -arr[i + 1][j]);
            addEdge(getIndex(pos[i][j]) + 1, getIndex(pos[i + 1][j + 1]), 1,
                    -arr[i + 1][j + 1]);
        }
    }
    for (j = 0; j < (int) arr[n].size(); j++) {
        addEdge(getIndex(pos[n][j]) + 1, des, 1, 0);
    }
    printf("%d\n", -MinCostMaxFlow());
}
void rule2() {
    int i, j;
    e = 0;
    src = 0;
    des = size + 1;
    V = des;
    memset(first, -1, sizeof(first));
    for (i = 0; i < (int) arr[1].size(); i++) {
        addEdge(src, pos[1][i], 1, -arr[1][i]);
    }
    for (i = 1; i < n; i++) {
        for (j = 0; j < (int) arr[i].size(); j++) {
            addEdge(pos[i][j], pos[i + 1][j], 1, -arr[i + 1][j]);
            addEdge(pos[i][j], pos[i + 1][j + 1], 1, -arr[i + 1][j + 1]);
        }
    }
    for (j = 0; j < (int) arr[n].size(); j++) {
        addEdge(pos[n][j], des, oo, 0);
    }
    printf("%d\n", -MinCostMaxFlow());
}
void rule3() {
    int i, j;
    e = 0;
    src = 0;
    des = size + 1;
    V = des;
    memset(first, -1, sizeof(first));
    for (i = 0; i < (int) arr[1].size(); i++) {
        addEdge(src, pos[1][i], 1, -arr[1][i]);
    }
    for (i = 1; i < n; i++) {
        for (j = 0; j < (int) arr[i].size(); j++) {
            addEdge(pos[i][j], pos[i + 1][j], oo, -arr[i + 1][j]);
            addEdge(pos[i][j], pos[i + 1][j + 1], oo, -arr[i + 1][j + 1]);
        }
    }
    for (j = 0; j < (int) arr[n].size(); j++) {
        addEdge(pos[n][j], des, oo, 0);
    }
    printf("%d\n", -MinCostMaxFlow());
}
int main() {
    int i, j;
    int tmp;
    while (~scanf("%d%d", &m, &n)) {
        size = 0;
        for (i = 1; i <= n; i++) {
            arr[i].clear();
            pos[i].clear();
            for (j = 0; j < m + i - 1; j++) {
                scanf("%d", &tmp);
                arr[i].push_back(tmp);
                pos[i].push_back(++size);
            }
        }
        rule1();
        rule2();
        rule3();
    }
    return 0;
}

（17）运输问题：网络费用流量。

 思路：

1。最小费用最大流。

2。最大费用最大流，费用乘以-1，求最小费用最大流。

#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#define oo 0x7FFFFFFF
#define MAXL 1010
#define MAXN 10010
#define MAXM 1000010
using namespace std;
int V, n, m, e;
int src, des;
int link[MAXN], father[MAXN];
int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
int dis[MAXN];
bool inq[MAXN];

int a[MAXN];
int b[MAXN];
int c[MAXL][MAXL];
void addEdge(int x, int y, int f, int c) {
    v[e] = y;
    flow[e] = f;
    cost[e] = c;
    next[e] = first[x];
    first[x] = e++;

    v[e] = x;
    flow[e] = 0;
    cost[e] = -c;
    next[e] = first[y];
    first[y] = e++;
}
bool SPFA() {
    int i, u;
    deque<int> q;
    memset(inq, false, sizeof(inq));
    for (i = 0; i <= V; i++) {
        dis[i] = oo;
    }
    dis[src] = 0;
    q.push_back(src);
    inq[src] = true;
    while (!q.empty()) {
        u = q.front();
        q.pop_front();
        inq[u] = false;
        for (i = first[u]; i != -1; i = next[i]) {
            if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
                dis[v[i]] = dis[u] + cost[i];
                father[v[i]] = u;
                link[v[i]] = i;
                if (!inq[v[i]]) {
                    inq[v[i]] = true;
                    if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
                        q.push_front(v[i]);
                    } else {
                        q.push_back(v[i]);
                    }
                }
            }
        }
    }
    return dis[des] != oo;
}
int MinCostMaxFlow() {
    int u;
    int ans;
    int tmp;
    for (ans = 0; SPFA();) {
        tmp = oo;
        for (u = des; u; u = father[u]) {
            tmp = min(tmp, flow[link[u]]);
        }
        for (u = des; u; u = father[u]) {
            flow[link[u]] -= tmp;
            flow[link[u] ^ 1] += tmp;
        }
        ans += tmp * dis[des];
    }
    return ans;
}
void calMinCostMaxFlow(int flag) {
    int i, j;
    src = 0;
    des = n + m + 1;
    V = des;
    e = 0;
    memset(first, -1, sizeof(first));
    for (i = 1; i <= m; i++) {
        addEdge(src, i, a[i], 0);
    }
    for (i = 1; i <= n; i++) {
        addEdge(m + i, des, b[i], 0);
    }
    for (i = 1; i <= m; i++) {
        for (j = 1; j <= n; j++) {
            addEdge(i, m + j, oo, c[i][j] * flag);
        }
    }
    printf("%d\n", flag * MinCostMaxFlow());
}
int main() {
    int i, j;
    while (~scanf("%d%d", &m, &n)) {
        for (i = 1; i <= m; i++) {
            scanf("%d", &a[i]);
        }
        for (i = 1; i <= n; i++) {
            scanf("%d", &b[i]);
        }
        for (i = 1; i <= m; i++) {
            for (j = 1; j <= n; j++) {
                scanf("%d", &c[i][j]);
            }
        }
        calMinCostMaxFlow(1);
        calMinCostMaxFlow(-1);
    }
    return 0;
}

（18）分配问题：二分图最佳匹配。 

思路：

同（17）运输问题。

#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#define oo 0x7FFFFFFF
#define MAXL 1010
#define MAXN 10010
#define MAXM 1000010
using namespace std;
int V, n, e;
int src, des;
int link[MAXN], father[MAXN];
int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
int dis[MAXN];
bool inq[MAXN];

int c[MAXL][MAXL];
void addEdge(int x, int y, int f, int c) {
    v[e] = y;
    flow[e] = f;
    cost[e] = c;
    next[e] = first[x];
    first[x] = e++;

    v[e] = x;
    flow[e] = 0;
    cost[e] = -c;
    next[e] = first[y];
    first[y] = e++;
}
bool SPFA() {
    int i, u;
    deque<int> q;
    memset(inq, false, sizeof(inq));
    for (i = 0; i <= V; i++) {
        dis[i] = oo;
    }
    dis[src] = 0;
    q.push_back(src);
    inq[src] = true;
    while (!q.empty()) {
        u = q.front();
        q.pop_front();
        inq[u] = false;
        for (i = first[u]; i != -1; i = next[i]) {
            if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
                dis[v[i]] = dis[u] + cost[i];
                father[v[i]] = u;
                link[v[i]] = i;
                if (!inq[v[i]]) {
                    inq[v[i]] = true;
                    if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
                        q.push_front(v[i]);
                    } else {
                        q.push_back(v[i]);
                    }
                }
            }
        }
    }
    return dis[des] != oo;
}
int MinCostMaxFlow() {
    int u;
    int ans;
    int tmp;
    for (ans = 0; SPFA();) {
        tmp = oo;
        for (u = des; u; u = father[u]) {
            tmp = min(tmp, flow[link[u]]);
        }
        for (u = des; u; u = father[u]) {
            flow[link[u]] -= tmp;
            flow[link[u] ^ 1] += tmp;
        }
        ans += tmp * dis[des];
    }
    return ans;
}
void calMinCostMaxFlow(int flag) {
    int i, j;
    src = 0;
    des = n + n + 1;
    V = des;
    e = 0;
    memset(first, -1, sizeof(first));
    for (i = 1; i <= n; i++) {
        for (j = 1; j <= n; j++) {
            addEdge(i, n + j, oo, c[i][j] * flag);
        }
    }
    for (i = 1; i <= n; i++) {
        addEdge(src, i, 1, 0);
        addEdge(n + i, des, 1, 0);
    }
    printf("%d\n", flag * MinCostMaxFlow());
}
int main() {
    int i, j;
    while (~scanf("%d", &n)) {
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= n; j++) {
                scanf("%d", &c[i][j]);
            }
        }
        calMinCostMaxFlow(1);
        calMinCostMaxFlow(-1);
    }
    return 0;
}

（19）负载平衡问题：最小代价供求。 

思路：

1。向相邻的左右两个点连边，流量为oo，费用为1。

2。若一个点库存比平均值多a，则从源向该点连边，流量为a，费用为0。

3。若一个点库存比平均值少a，则从该点向汇连边，流量为a，费用为0。

4。求最小费用最大流。

#include<cstdio>
#include<cstring>
#include<queue>
#define oo 123456
#define MAXN 100010
#define MAXM 1000010
using namespace std;
int V, n, m, e;
int src, des;
int lk[MAXN], father[MAXN];
int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
int dis[MAXN];
bool inq[MAXN];

int arr[MAXN];
void addEdge(int x, int y, int f, int c) {
    v[e] = y;
    flow[e] = f;
    cost[e] = c;
    next[e] = first[x];
    first[x] = e++;

    v[e] = x;
    flow[e] = 0;
    cost[e] = -c;
    next[e] = first[y];
    first[y] = e++;
}
bool SPFA() {
    int i, u;
    deque<int> q;
    memset(inq, false, sizeof(inq));
    for (i = 0; i <= V; i++) {
        dis[i] = oo;
    }
    dis[src] = 0;
    q.push_back(src);
    inq[src] = true;
    while (!q.empty()) {
        u = q.front();
        q.pop_front();
        inq[u] = false;
        for (i = first[u]; i != -1; i = next[i]) {
            if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
                dis[v[i]] = dis[u] + cost[i];
                father[v[i]] = u;
                lk[v[i]] = i;
                if (!inq[v[i]]) {
                    inq[v[i]] = true;
                    if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
                        q.push_front(v[i]);
                    } else {
                        q.push_back(v[i]);
                    }
                }
            }
        }
    }
    return dis[des] != oo;
}
int MinCostMaxFlow() {
    int u;
    int ans;
    int tmp;
    for (ans = 0; SPFA();) {
        tmp = oo;
        for (u = des; u; u = father[u]) {
            tmp = min(tmp, flow[lk[u]]);
        }
        for (u = des; u; u = father[u]) {
            flow[lk[u]] -= tmp;
            flow[lk[u] ^ 1] += tmp;
        }
        ans += tmp * dis[des];
    }
    return ans;
}
int main() {
    int i, j;
    int sum;
    while (~scanf("%d", &n)) {
        e = 0;
        src = 0;
        des = n + 1;
        V = des;
        memset(first, -1, sizeof(first));
        sum = 0;
        for (i = 1; i <= n; i++) {
            scanf("%d", &arr[i]);
            sum += arr[i];
        }
        sum /= n;
        for (i = 1; i <= n; i++) {
            arr[i] -= sum;
            if (arr[i] > 0) {
                addEdge(src, i, arr[i], 0);
            } else if (arr[i] < 0) {
                addEdge(i, des, -arr[i], 0);
            }
            j = i + 1;
            if (j > n) {
                j = 1;
            }
            addEdge(i, j, oo, 1);
            addEdge(j, i, oo, 1);
            j = i - 1;
            if (j < 1) {
                j = n;
            }
            addEdge(i, j, oo, 1);
            addEdge(j, i, oo, 1);
        }
        printf("%d\n", MinCostMaxFlow());
    }
    return 0;
}

（20）深海机器人问题：线性规划网络优化。 

思路：

1。每个权值只能取一次，流量设为1。

2。每条路径可以取多次，流量设为oo。

3。最大费用最大流。

#include<cstdio>
#include<cstring>
#include<queue>
#define oo 123456
#define MAXN 100010
#define MAXM 1000010
using namespace std;
int V, n, m, e;
int src, des;
int lk[MAXN], father[MAXN];
int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
int dis[MAXN];
bool inq[MAXN];

void addEdge(int x, int y, int f, int c) {
    v[e] = y;
    flow[e] = f;
    cost[e] = c;
    next[e] = first[x];
    first[x] = e++;

    v[e] = x;
    flow[e] = 0;
    cost[e] = -c;
    next[e] = first[y];
    first[y] = e++;
}
bool SPFA() {
    int i, u;
    deque<int> q;
    memset(inq, false, sizeof(inq));
    for (i = 0; i <= V; i++) {
        dis[i] = oo;
    }
    dis[src] = 0;
    q.push_back(src);
    inq[src] = true;
    while (!q.empty()) {
        u = q.front();
        q.pop_front();
        inq[u] = false;
        for (i = first[u]; i != -1; i = next[i]) {
            if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
                dis[v[i]] = dis[u] + cost[i];
                father[v[i]] = u;
                lk[v[i]] = i;
                if (!inq[v[i]]) {
                    inq[v[i]] = true;
                    if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
                        q.push_front(v[i]);
                    } else {
                        q.push_back(v[i]);
                    }
                }
            }
        }
    }
    return dis[des] != oo;
}
int MinCostMaxFlow() {
    int u;
    int ans;
    int tmp;
    for (ans = 0; SPFA();) {
        tmp = oo;
        for (u = des; u; u = father[u]) {
            tmp = min(tmp, flow[lk[u]]);
        }
        for (u = des; u; u = father[u]) {
            flow[lk[u]] -= tmp;
            flow[lk[u] ^ 1] += tmp;
        }
        ans += tmp * dis[des];
    }
    return ans;
}
int main() {
    int a, b;
    int p, q;
    int i, j;
    int x, y, val;
    while (~scanf("%d%d%d%d", &a, &b, &p, &q)) {
        e = 0;
        src = 0;
        des = (p + 1) * (q + 1) + 1;
        V = des;
        memset(first, -1, sizeof(first));
        for (i = 0; i <= p; i++) {
            for (j = 1; j <= q; j++) {
                scanf("%d", &x);
                addEdge(i * (q + 1) + j, i * (q + 1) + j + 1, 1, -x);
                addEdge(i * (q + 1) + j, i * (q + 1) + j + 1, oo, 0);
            }
        }
        for (i = 0; i <= q; i++) {
            for (j = 1; j <= p; j++) {
                scanf("%d", &x);
                addEdge((j - 1) * (q + 1) + i + 1, j * (q + 1) + i + 1, 1, -x);
                addEdge((j - 1) * (q + 1) + i + 1, j * (q + 1) + i + 1, oo, 0);
            }
        }
        while (a--) {
            scanf("%d%d%d", &val, &y, &x);
            addEdge(src, y * (q + 1) + x + 1, val, 0);
        }
        while (b--) {
            scanf("%d%d%d", &val, &y, &x);
            addEdge(y * (q + 1) + x + 1, des, val, 0);
        }
        printf("%d\n", -MinCostMaxFlow());
    }
}

（21）最长k可重区间集问题：最大权不相交路径。 

思路：

1。对所有端点排序后，离散化。

2。源到1，流量为k，费用为0。最后一个点到汇，流量为oo，费用为0。

3。若有区间[x,y]，则x向y连边，流量为1，费用为x-y。

4。最大费用最大流。

#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
#define oo 123456
#define MAXN 100010
#define MAXM 1000010
using namespace std;
int V, n, m, e;
int src, des;
int lk[MAXN], father[MAXN];
int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
int dis[MAXN];
bool inq[MAXN];

int arr[MAXN];
int size;
struct point {
    int x, y;
} p[MAXN];
void addEdge(int x, int y, int f, int c) {
    v[e] = y;
    flow[e] = f;
    cost[e] = c;
    next[e] = first[x];
    first[x] = e++;

    v[e] = x;
    flow[e] = 0;
    cost[e] = -c;
    next[e] = first[y];
    first[y] = e++;
}
bool SPFA() {
    int i, u;
    deque<int> q;
    memset(inq, false, sizeof(inq));
    for (i = 0; i <= V; i++) {
        dis[i] = oo;
    }
    dis[src] = 0;
    q.push_back(src);
    inq[src] = true;
    while (!q.empty()) {
        u = q.front();
        q.pop_front();
        inq[u] = false;
        for (i = first[u]; i != -1; i = next[i]) {
            if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
                dis[v[i]] = dis[u] + cost[i];
                father[v[i]] = u;
                lk[v[i]] = i;
                if (!inq[v[i]]) {
                    inq[v[i]] = true;
                    if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
                        q.push_front(v[i]);
                    } else {
                        q.push_back(v[i]);
                    }
                }
            }
        }
    }
    return dis[des] != oo;
}
int MinCostMaxFlow() {
    int u;
    int ans;
    int tmp;
    for (ans = 0; SPFA();) {
        tmp = oo;
        for (u = des; u; u = father[u]) {
            tmp = min(tmp, flow[lk[u]]);
        }
        for (u = des; u; u = father[u]) {
            flow[lk[u]] -= tmp;
            flow[lk[u] ^ 1] += tmp;
        }
        ans += tmp * dis[des];
    }
    return ans;
}
int main() {
    int i;
    int m;
    int x, y;
    while (~scanf("%d%d", &n, &m)) {
        e = 0;
        src = 0;
        des = n + n + 1;
        V = des;
        memset(first, -1, sizeof(first));
        size = 0;
        for (i = 0; i < n; i++) {
            scanf("%d%d", &p[i].x, &p[i].y);
            arr[size++] = p[i].x;
            arr[size++] = p[i].y;
        }
        sort(arr, arr + size);
        size = unique(arr, arr + size) - arr;
        addEdge(src, 1, m, 0);
        addEdge(size, des, oo, 0);
        for (i = 2; i <= size; i++) {
            addEdge(i - 1, i, oo, 0);
        }
        for (i = 0; i < n; i++) {
            x = lower_bound(arr, arr + size, p[i].x) - arr + 1;
            y = lower_bound(arr, arr + size, p[i].y) - arr + 1;
            addEdge(x, y, 1, p[i].x - p[i].y);
        }
        printf("%d\n", -MinCostMaxFlow());
    }
    return 0;
}

（24）骑士共存问题：二分图最大独立集。

思路：

1。冲突的位置相互连边。

2.。添加源，汇。

3。求最大流。

#include<cstdio>
#include<cstring>
#include<vector>
#define MAXL 210
#define MAXN 100010
#define MAXM 1000010
#define oo 0x7FFFFFFF
using namespace std;
int first[MAXN], next[MAXM], v[MAXM], cost[MAXM], e;
int n;
int src, des;
bool flag[MAXL][MAXL];
int go[][2] = { { 1, 2 }, { 1, -2 }, { -1, 2 }, { -1, -2 }, { 2, 1 }, { 2, -1 },
        { -2, 1 }, { -2, -1 } };
inline void addEdge(int x, int y, int val) {
    v[e] = y;
    cost[e] = val;
    next[e] = first[x];
    first[x] = e++;

    v[e] = x;
    cost[e] = 0;
    next[e] = first[y];
    first[y] = e++;
}
int SAP() {
    int pre[MAXN], cur[MAXN], dis[MAXN], gap[MAXN];
    int flow = 0;
    int aug = oo;
    int x, y;
    bool flag;
    for (int i = 0; i < n; i++) {
        cur[i] = first[i];
        gap[i] = dis[i] = 0;
    }
    gap[src] = n;
    x = pre[src] = src;
    while (dis[src] < n) {
        flag = false;
        for (int &j = cur[x]; j != -1; j = next[j]) {
            y = v[j];
            if (cost[j] > 0 && dis[x] == dis[y] + 1) {
                flag = true;
                aug = min(aug, cost[j]);
                pre[y] = x;
                x = y;
                if (x == des) {
                    flow += aug;
                    while (x != src) {
                        x = pre[x];
                        cost[cur[x]] -= aug;
                        cost[cur[x] ^ 1] += aug;
                    }
                    aug = oo;
                }
                break;
            }
        }
        if (flag) {
            continue;
        }
        int tmp = n;
        for (int j = first[x]; j != -1; j = next[j]) {
            y = v[j];
            if (cost[j] > 0 && dis[y] < tmp) {
                tmp = dis[y];
                cur[x] = j;
            }
        }
        if ((--gap[dis[x]]) == 0) {
            break;
        }
        gap[dis[x] = tmp + 1]++;
        x = pre[x];
    }
    return flow;
}
int getIndex(int x, int y) {
    return (x - 1) * n + y;
}
int main() {
    int m;
    int i, j, k;
    int x, y;
    int ans;
    while (~scanf("%d%d", &n, &m)) {
        src = 0;
        des = 2 * n * n + 1;
        e = 0;
        memset(first, -1, sizeof(first));
        memset(flag, false, sizeof(flag));
        for (i = 0; i < m; i++) {
            scanf("%d%d", &x, &y);
            flag[x][y] = true;
        }
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= n; j++) {
                if (flag[i][j]) {
                    continue;
                }
                addEdge(src, getIndex(i, j), 1);
                addEdge(n * n + getIndex(i, j), des, 1);
                for (k = 0; k < 8; k++) {
                    x = i + go[k][0];
                    y = j + go[k][1];
                    if (x > 0 && x <= n && y > 0 && y <= n && !flag[x][y]) {
                        addEdge(getIndex(i, j), n * n + getIndex(x, y), 1);
                    }
                }
            }
        }
        ans = n * n - m;
        n = des + 1;
        printf("%d\n", ans - SAP() / 2);
    }
    return 0;
}