最大流、最小割、费用流模板（EK算法为基础）

目录

EK算法模板：

EK算法基础上求最小割：

最小费用最大流：

---

EK算法模板：

#include<iostream>
#include<queue> 
#include<cstring>
using namespace std;

const int N = 1010, M = 20010, INF = 1e9;

int n, m, S, T;
int h[N], e[M], ne[M], f[M], idx;
int d[N], pre[N];
bool st[N];


void add(int a, int b, int c)
{
	e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx++;
	e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx++;
}

bool bfs()
{
	memset(st, false, sizeof st);
	queue<int> q; 
	q.push(S);
	st[S] = true;
	d[S] = INF; 
	
	while (q.size())
	{
		auto t = q.front();
		q.pop();
		
		for (int i = h[t]; ~i; i = ne[i])
		{
			int ver = e[i];
			if (!st[ver] && f[i])
			{
				st[ver] = true;
				d[ver] = min(d[t], f[i]);
				pre[ver] = i;
				if (ver == T) return true;
				q.push(ver);
			}
			
		}
	}
	return false;
}

int EK()
{
	int r = 0;
	while(bfs())
	{
		r += d[T];
		for (int i = T; i != S; i = e[pre[i] ^ 1])
		{
			f[pre[i]] -= d[T], f[pre[i] ^ 1] += d[T];
		}
		
	}
	return r;
}

int main()
{
	cin >> n >> m >> S >> T;
	memset(h, -1, sizeof h);
	
	while (m--)
	{
		int a, b, c;
		cin >> a >> b >> c;
		add(a, b, c);	
	}	
	
	cout << EK() << endl;
}

EK算法基础上求最小割：

#include <iostream>
#include <queue>
#include <cstring>
using namespace std;

const int N = 1010, M = 20010, INF = 1e9;

int n, m, S, T;
int h[N], e[M], ne[M], f[M], idx;
int d[N], pre[N];
bool st[N];

void add(int a, int b, int c)
{
    e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx++;
    e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx++;
}

bool bfs()
{
    memset(st, false, sizeof st);
    queue<int> q;
    q.push(S);
    st[S] = true;
    d[S] = INF;

    while (q.size())
    {
        auto t = q.front();
        q.pop();

        for (int i = h[t]; ~i; i = ne[i])
        {
            int ver = e[i];
            if (!st[ver] && f[i])
            {
                st[ver] = true;
                d[ver] = min(d[t], f[i]);
                pre[ver] = i;
                if (ver == T)
                    return true;
                q.push(ver);
            }
        }
    }
    return false;
}

int EK()
{
    int r = 0;
    while (bfs())
    {
        int flow = d[T];
        r += flow;
        for (int i = T; i != S; i = e[pre[i] ^ 1])
        {
            f[pre[i]] -= flow;
            f[pre[i] ^ 1] += flow;
        }
    }
    return r;
}


void dfs(int u)
{
	 
    st[u] = true;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int v = e[i];
        if (!st[v] && f[i])
            dfs(v);
    }
}

int main()
{
    cin >> n >> m >> S >> T;
    memset(h, -1, sizeof h);

    while (m--)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }

    EK();

    dfs(S);
	
	
    for (int i = 0; i < idx; i += 2)
    {
        int a = e[i ^ 1], b = e[i];
        if (st[a] && !st[b])
            cout << a << " " << b << endl;
    }

    return 0;
}

最小费用最大流：

#include<iostream>
#include<queue> 
#include<cstring>
using namespace std;
 
const int N = 1010, M = 20010, INF = 1e9;
 
int n, m, S, T;
int h[N], e[M], ne[M], f[M], w[M], idx;
int pre[N], incf[N], dist[N];
bool st[N];


void add(int a, int b, int c, int d)
{
	e[idx] = b, f[idx] = c, w[idx] = d, ne[idx] = h[a], h[a] = idx++;
	e[idx] = a, f[idx] = 0, w[idx] = -d, ne[idx] = h[b], h[b] = idx++;
}
 
bool spfa()
{
    memset(dist, 0x3f, sizeof dist);
    memset(st, false, sizeof st);
    memset(incf, 0, sizeof incf);
    dist[S] = 0;

    queue<int> q;
    q.push(S);
    st[S] = true;
    incf[S] = INF;

    while (q.size())
    {
        auto t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int ver = e[i];
            if (f[i] && dist[ver] > dist[t] + w[i])
            {
                dist[ver] = dist[t] + w[i];
                pre[ver] = i;
                incf[ver] = min(f[i], incf[t]);
                
                if (!st[ver])     
                {
                    q.push(ver);
                    st[ver] = true;
                }
            }
        }
    }

	return incf[T] > 0;
}

 
void EK(int& flow, int& cost)
{
	flow = cost = 0;
	while(spfa())
	{
		int t = incf[T];
		flow += t, cost += t * dist[T];
		
		for (int i = T; i != S; i = e[pre[i] ^ 1])
		{
			f[pre[i]] -= t;
			f[pre[i] ^ 1] += t;
		}
	}

}
 
int main()
{
	cin >> n >> m >> S >> T;
	memset(h, -1, sizeof h);
	
	while (m--)
	{
		int a, b, c, d;
		cin >> a >> b >> c >> d;
		add(a, b, c, d);	
	}	
	
	int flow, cost;
	EK(flow, cost);
	
	cout << flow << " "<< cost << endl;
}