网络流模板-CFANZ编程社区

sap:

const int N = 12010, INF = 0x3f3f3f3f;
struct edge
{
    int to, cap, next;
}g[N*100];
int level[N], cur[N] , pre[N], gap[N];
int cnt,head[N];
int nv; //图的点数，记得设置
void init() //初始化
{
    cnt = 0;
    memset(head, -1, sizeof head);
}
void add_edge(int v, int u, int cap)
{//加边，此处为有向边，若是无向边，则把正向边和反向边均设为cap
    g[cnt].to = u, g[cnt].cap = cap, g[cnt].next = head[v], head[v] = cnt++;
    g[cnt].to = v, g[cnt].cap = 0, g[cnt].next = head[u], head[u] = cnt++;
}
int sap(int s, int t)
{
    memset(level, 0, sizeof level);
    memset(gap, 0, sizeof gap);
    memcpy(cur, head, sizeof head);
    gap[0] = nv;
    int v = pre[s] = s, flow = 0, aug = INF;
    while(level[s] < nv)
    {
        bool flag = false;
        for(int &i = cur[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(g[i].cap > 0 && level[v] == level[u] + 1)
            {
                flag = true;
                pre[u] = v;
                v = u;
                aug = min(aug, g[i].cap);
                if(v == t)
                {
                    flow += aug;
                    while(v != s)
                    {
                        v = pre[v];
                        g[cur[v]].cap -= aug;
                        g[cur[v]^1].cap += aug;
                    }
                    aug = INF;
                }
                break;
            }
        }
        if(flag) continue;
        int minlevel = nv;
        for(int i = head[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(g[i].cap > 0 && level[u] < minlevel)
                minlevel = level[u], cur[v] = i;
        }
        if(--gap[level[v]] == 0) break;
        level[v] = minlevel + 1;
        gap[level[v]]++;
        v = pre[v];
    }
    return flow;
}

isap:

//跟sap基本一样，多了一个bfs函数
const int N = 2600, INF = 0x3f3f3f3f;
struct edge
{
    int to, cap, next;
} g[N*100];
int cnt, head[N];
int gap[N], que[N], level[N], pre[N], cur[N];
int nv; //图的点数，记得设置！
void init()
{
    cnt = 0;
    memset(head, -1, sizeof head);
}
void add_edge(int v, int u, int cap)
{//加边，此处为有向边，若是无向边，则把正向边和反向边均设为cap
    g[cnt].to = u, g[cnt].cap = cap, g[cnt].next = head[v], head[v] = cnt++;
    g[cnt].to = v, g[cnt].cap = 0, g[cnt].next = head[u], head[u] = cnt++;
}
void bfs(int t)//反向bfs，进行标号
{
    queue<int> que;
    memset(level, -1, sizeof level);
    memset(gap, 0, sizeof gap);
    level[t] = 0;
    gap[level[t]]++;
    que.push(t);
    while(! que.empty())
    {
        int v = que.front(); que.pop();
        for(int i = head[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(level[u] < 0)
            {
                level[u] = level[v] + 1;
                gap[level[u]]++;
                que.push(u);
            }
        }
    }
}
int isap(int s, int t)
{
    bfs(t);
    memcpy(cur, head, sizeof head);
    int v = pre[s] = s, flow = 0, aug = INF;
    while(level[s] < nv)
    {
        bool flag = false;
        for(int &i = cur[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(g[i].cap > 0 && level[v] == level[u] + 1)
            {
                flag = true;
                pre[u] = v;
                v = u;
                aug = min(aug, g[i].cap);
                if(v == t)
                {
                    flow += aug;
                    while(v != s)
                    {
                        v = pre[v];
                        g[cur[v]].cap -= aug;
                        g[cur[v]^1].cap += aug;
                    }
                    aug = INF;
                }
                break;
            }
        }
        if(flag) continue;
        int minlevel = nv;
        for(int i = head[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(g[i].cap > 0 && level[u] < minlevel)
                minlevel = level[u], cur[v] = i;
        }
        if(--gap[level[v]] == 0) break;
        level[v] = minlevel + 1;
        gap[level[v]]++;
        v = pre[v];
    }
    return flow;
}

dinic:

//这份模板中有三个dfs函数，第一个是单路增广后两个是多路增广，任选一个即可，实测三个函数差别不大
const int N = 20010, INF = 0x3f3f3f3f;
struct edge
{
    int to, cap, next;
} g[N*50];
int iter[N], level[N];
int cnt, head[N];
void init()
{
    cnt = 0;
    memset(head, -1, sizeof head);
}
void add_edge(int v, int u, int cap)
{
    g[cnt].to = u, g[cnt].cap = cap, g[cnt].next = head[v], head[v] = cnt++;
    g[cnt].to = v, g[cnt].cap = 0, g[cnt].next = head[u], head[u] = cnt++;
}
bool bfs(int s, int t)
{
    memset(level, -1, sizeof level);
    queue<int> que;
    level[s] = 0;
    que.push(s);
    while(! que.empty())
    {
        int v = que.front();
        que.pop();
        for(int i = head[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(g[i].cap > 0 && level[u] < 0)
            {
                level[u] = level[v] + 1;
                que.push(u);
            }
        }
    }
    return level[t] != -1;
}
int dfs(int v, int t, int f)
{
    if(v == t) return f;
    for(int &i = iter[v]; i != -1; i = g[i].next)
    {
        int u = g[i].to;
        if(g[i].cap > 0 && level[v]+1 == level[u])
        {
            int d = dfs(u, t, min(f, g[i].cap));
            if(d > 0)
            {
                g[i].cap -= d, g[i^1].cap += d;
                return d;
            }
        }
    }
    return 0;
}
int dfs(int v, int t, int f)
{
    if(v == t) return f;
    int num = 0;
    for(int &i = iter[v]; i != -1; i = g[i].next)
    {
        int u = g[i].to;
        if(g[i].cap > 0 && level[v]+1 == level[u])
        {
            int d = dfs(u, t, min(f - num, g[i].cap));
            g[i].cap -= d, g[i^1].cap += d, num += d;
            if(num == f) break;
        }
    }
    if(! num) level[v] = -1;
    return num;
}
int dfs(int v, int t, int f)
{
    if(v == t) return f;
    int num = f;
    for(int &i = iter[v]; i != -1; i = g[i].next)
    {
        int u = g[i].to;
        if(g[i].cap > 0 && level[v]+1 == level[u])
        {
            int d = dfs(u, t, min(num, g[i].cap));
            g[i].cap -= d, g[i^1].cap += d, num -= d;
            if(num == 0) break;
        }
    }
    if(num == f) level[v] = -1;
    return f - num;
}
int dinic(int s, int t)
{
    int flow = 0, f;
    while(true)
    {
        if(! bfs(s, t)) break;
        memcpy(iter, head, sizeof head);
        while(f = dfs(s, t, INF), f > 0) flow += f;
    }
    return flow;
}

费用流：

const int N = 410;
const int INF = 0x3f3f3f3f;
struct edge
{
    int to, cap, cost, next;
} g[N*N*4];
int cnt, head[N];
int dis[N], pre[N];
bool vis[N];
void init()
{
    cnt = 0;
    memset(head, -1, sizeof head);
}
void add_edge(int v, int u, int cap, int cost)
{
    g[cnt].to = u, g[cnt].cap = cap, g[cnt].cost = cost, g[cnt].next = head[v], head[v] = cnt++;
    g[cnt].to = v, g[cnt].cap = 0, g[cnt].cost = -cost, g[cnt].next = head[u], head[u] = cnt++;
}
bool spfa(int s, int t)
{
    memset(dis, 0x3f, sizeof dis);
    memset(vis, 0, sizeof vis);
    memset(pre, -1, sizeof pre);
    queue<int> que;
    que.push(s);
    dis[s] = 0, vis[s] = true;
    while(! que.empty())
    {
        int v = que.front(); que.pop();
        vis[v] = false;
        for(int i = head[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(g[i].cap > 0 && dis[u] > dis[v] + g[i].cost)
            {
                dis[u] = dis[v] + g[i].cost;
                pre[u] = i;
                if(! vis[u]) que.push(u), vis[u] = true;
            }
        }
    }
    return dis[t] != INF;
}
int cost_flow(int s, int t, int flow)//求从s到t的流量为flow的最小费用。不用flow作为限制，就变成了最小费用可行流
{
    int res = 0;
    while(flow > 0)
    {
        if(! spfa(s, t)) return -1;
        int d = flow;
        for(int i = pre[t]; i != -1; i = pre[g[i^1].to])
            d = min(d, g[i].cap);
        for(int i = pre[t]; i != -1; i = pre[g[i^1].to])
            g[i].cap -= d, g[i^1].cap += d;
        flow -= d;
        res += d * dis[t];
    }
    return res;
}