最大流笔记（二）

3. 最大流变式

3.1 多源汇的情况

添加一个超级源点和超级汇点，超级源点到每一个源点建一条容量为无穷大的边，每个汇点到超级汇点建一条容量为无穷大的边，从超级源点到超级汇点跑最大流。

3.2 点上有容量限制的情况

如果限制条件为\(i\)点的流量不能超过\(c\)，就把\(i\)点拆为\(i_{in}\)和\(i_{out}\)两个点并建一条从\(i_{in}\)到\(i_{out}\)的容量为\(c\)的边，原图中进入\(i\)点的边都连到\(i_{in}\)点，从\(i\)出发的边都从\(i_{out}\)出发。

例题 POJ 3281 Dining

Description

Farmer John有\(N\)头牛，\(F\)种食物和\(D\)种饮料，每头牛都有自己喜欢的若干种食物和若干种饮料，已知一头牛最多能吃一种食物和一种饮料，每种饮料或食物最多能被一头牛吃，求以上条件下，最多能有多少头牛能吃到他所喜爱的食物和饮料。

Solution

建三排点，中间\(N\)个点代表\(N\)头牛，左边\(F\)个点代表\(F\)种食物，右边\(D\)个点代表\(D\)种饮料。每种食物向喜爱它的牛建一条容量为\(1\)的边，每头再向它喜爱的每种饮料建一条容量为\(1\)的边。又因为每头牛最多只计算一次，故将表示每头牛的点拆为两个，建容量为\(1\)的边。建立源点\(s\)，与每种食物建容量为\(1\)的边，建立汇点\(t\)，每种饮料与它建容量为\(1\)的边，跑最大流即为最终答案。

3.3 最小费用最大流

Description

给出一个\(N\)个点\(M\)条边的有向图，每条边上有一个容量限制\(cap\)和单位流量的花费\(cost\)。给出源点\(s\)和汇点\(t\)，求从源点\(s\)到汇点\(t\)的花费最小的最大流。输出最小花费和最大流的值。

Solution

初始时流量为\(0\)，花费也为\(0\)，此时是当前流量下的最小花费。每次增广，我们不再找任意增广路径，而是找花费最小的路径，这样就保证了每次迭代得到的都是当前流量下的最小花费。如果已经不能再增广了，说明已经找到了最大流量下的最小花费。寻找花费最小的路径就是在以花费为边权的图上找最短路。

Code

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int N = 1e3 + 10;
const int M = 2e3 + 10;

struct Edge 
{
    int from, to, next, cap, cost;
    Edge() {}
    Edge(int from, int to, int next, int cap, int cost) : 
        from(from), to(to), next(next), cap(cap), cost(cost) {}
} edge[M];
int head[N], tot;

void add(int from, int to, int cap, int cost) 
{
    edge[tot] = Edge(from, to, head[from], cap, cost);
    head[from] = tot++;
    edge[tot] = Edge(to, from, head[to], 0, -cost);
    head[to] = tot++;
}

void init() 
{
    memset(head, -1, sizeof(head));
    tot = 0;
}

int dis[N], pre[N];
bool vis[N];
queue<int> q;
bool spfa(int s, int t) 
{
    while (!q.empty()) q.pop();
    memset(dis, 0x3f, sizeof(dis));
    memset(vis, false, sizeof(vis));
    memset(pre, -1, sizeof(pre));
    q.push(s); vis[s] = true; dis[s] = 0;     
    while (!q.empty()) 
    {
        int u = q.front(); q.pop(); vis[u] = false;
        for (int i = head[u]; i != -1; i = edge[i].next) 
            if (edge[i].cap && dis[u] + edge[i].cost < dis[edge[i].to]) 
            {
                int v = edge[i].to;
                dis[v] = dis[u] + edge[i].cost;
                pre[v] = i;
                if (!vis[v]) q.push(v), vis[v] = true;
            }
    }
    return dis[t] < INF; 
}

int mcmf(int s, int t, int& maxflow) 
{
    int mincost = 0;
    maxflow = 0;
    while (spfa(s, t)) 
    {
        int flow = INF;
        for (int i = pre[t]; i != -1; i = pre[edge[i].from]) 
            flow = min(flow, edge[i].cap);
        for (int i = pre[t]; i != -1; i = pre[edge[i].from]) 
        {
            edge[i].cap -= flow;
            edge[i ^ 1].cap += flow;
            mincost += edge[i].cost * flow;
        }
        maxflow += flow;
    }
    return mincost;
}

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    init();
    while (m--)
    {
        int u, v, cap, cost;
        scanf("%d%d%d%d", &u, &v, &cap, &cost);
        add(u, v, cap, cost);
    }
    int s, t, maxflow;
    scanf("%d%d", &s, &t);
    int mincost = mcmf(s, t, maxflow);
    printf("%d %d\n", mincost, maxflow);
    return 0;
}

Input

第一行给出两个整数\(n\)和\(m\)，表示结点数和边数。
接下来\(m\)行，每行给出\(4\)个整数\(u\)，\(v\)，\(w\)，\(c\)，表示从\(u\)到\(v\)有一条容量为\(w\)，单位流量花费为\(c\)的边。
最后一行给出两个整数\(s\)和\(t\)，表示源点和汇点。

Output

输出两个整数，分别表示最小花费和最大流。

Sample Input

5 5
1 2 2 2
1 3 3 2
2 4 3 1
3 4 2 3
4 5 2 1
1 5

Sample Output

8 2

转载于:https://www.cnblogs.com/dadamrx/p/7400591.html