网络流入门

最新推荐文章于 2020-11-10 19:09:44 发布

wyyyyyyyy_

最新推荐文章于 2020-11-10 19:09:44 发布

阅读量294

点赞数

分类专栏： c++ 文章标签：网络流入门

本文链接：https://blog.csdn.net/wyyyyyyyy_/article/details/97491421

版权

c++ 专栏收录该内容

26 篇文章 1 订阅

订阅专栏

最大流模板

这是一道模板题。

给定 n 个点，m 条边，给定每条边的容量，求从点 s 到点 t 的最大流。

输入格式:

第一行四个整数n,m,s,t。

接下来的 m 行，每行三个整数u,v,c，表示从 u 到 v，流量为 c 的一条边。

数据保证有 1≤n≤100,1≤m≤5000,0≤c≤231−1。

输出格式:

输出点 s 到点 t 的最大流。

输入样例:

输出样例:

代码

#include<bits/stdc++.h>
#define int long long
const int INF = 0x3f3f3f3f;
const int maxn = 3e5+10;
using namespace std;
struct edge {
    int v, c, next;
} e[maxn<<1];
int s,t,n,head[maxn],q[maxn],level[maxn],tot;//s为起始点，t为终点，n为有几个节点
void add_edge(int u, int v, int c)//链式前向星//u是起点，v是终点，c是权值
{
    e[tot] = (edge){ v, c, head[u] };
    head[u] = tot++;
}
bool BFS()
{
    memset(level,0, sizeof(level));
    q[1] = s;//q[]模拟了一个队列，hd为头指针，tl为尾指针，level[]为点的层次
    level[s] = 1;
    int hd = 0,tl = 1;
    while (hd !=  tl)
    {
        hd++;
        for(int i = head[q[hd]]; i != -1; i = e[i].next)
        {
            if(e[i].c && !level[e[i].v])
            {
                tl++;
                level[e[i].v] = level[q[hd]] + 1;
                q[tl] = e[i].v;
                if (e[i].v == t)
                    return true;
            }
        }
    }
    return false;
}
int DFS(int f, int u)
{
    if (u == t)
        return f;
    int d = 0, used = 0;
    for (int i = head[u];i != -1;i = e[i].next)
    {
        if (e[i].c && level[u] == level[e[i].v] - 1)
        {
            if ((d = DFS(min(f - used, e[i].c), e[i].v)))
            {
                e[i].c -= d;
                e[i ^ 1].c += d;
                used += d;
            }
        }
    }
    if (!used)
        level[u] = 0;
    return used;
}
int Dinic()
{
    int max_flow = 0;
    while(BFS())
    {
        int d = 0;
        while ((d = DFS(INF, s)))
            max_flow += d;
    }
    return max_flow;
}
signed main()
{
    int m,u,w,v;//u为起点，w为终点，v为权值
    cin >> n >> m >> s >> t;
    memset(head, -1, sizeof(head));
    for (int i = 1; i <= m; i++)
    {
        cin >> u >> v >> w;
        add_edge(u, v, w);
        add_edge(v, u, 0);
    }
    cout << Dinic() << endl;
    return 0;
}

最小费用流模板

这是一道模板题。

给定一个图，每条边有容量和费用，使用每条边的单位流量需要支付特定的费用。给定源点 1和汇点 n，求图的最大流和最大流需要支付的最小费用。

输入格式:

第一行两个整数n,m，表示有 n 个点 m 条边。

从第二行开始的之后 m 行，每行四个整数si,ti,ci,wi 表示一条从 si 到 ti 的边，容量为ci，单位流量需要支付的费用为wi。

数据保证有1≤n≤400,0≤m≤15000,wi≥0,保证输入数据、中间结果以及答案在 32 位有符号整数范围内。

输出格式:

一行两个整数，分别表示最大流和最大流需要支付的最小费用。

输入样例:

在这里给出一组输入。例如：

8 23
2 3 2147483647 1
1 3 1 1
2 4 2147483647 2
1 4 1 2
2 8 2 0
3 5 2147483647 3
1 5 1 3
3 6 2147483647 4
1 6 1 4
3 8 2 0
3 2 2147483647 0
4 6 2147483647 5
1 6 1 5
4 7 2147483647 6
1 7 1 6
4 8 2 0
4 2 2147483647 0
5 8 0 0
5 2 2147483647 0
6 8 0 0
6 2 2147483647 0
7 8 0 0
7 2 2147483647 0

输出样例:

在这里给出相应的输出。例如：

6 24

代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 1e4+10;
const int maxm = 1e5+10;
const int inf = 0x3f3f3f3f;
struct Edge
{
    int to,next,cap,flow,cost;
}edge[maxm];
int head[maxn],tol,pre[maxn],dis[maxn],N;
bool vis[maxn];
void Init(int n)
{
    N = n;
    tol = 0;
    memset(head,-1, sizeof(head));
}
void add_edge(int u,int v,int cap,int cost)
{
    edge[tol].to = v;
    edge[tol].cap = cap;
    edge[tol].cost = cost;
    edge[tol].flow = 0;
    edge[tol].next = head[u];
    head[u] = tol++;

    edge[tol].to = u;
    edge[tol].cap = 0;
    edge[tol].cost = -cost;
    edge[tol].flow = 0;
    edge[tol].next = head[v];
    head[v] = tol++;
}
bool Spfa(int s,int t)
{
    queue<int>q;
    while(!q.empty())
        q.pop();
    for(int i = 0;i <= N; i++)
    {
        dis[i] = inf;
        vis[i] = false;
        pre[i] = -1;
    }
    dis[s] = 0;
    vis[s] = true;
    q.push(s);
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        vis[u] = false;
        for(int i = head[u];i != -1;i = edge[i].next)
        {
            int v = edge[i].to;
            if(edge[i].cap > edge[i].flow && dis[v] > dis[u] + edge[i].cost)
            {
                dis[v] = dis[u] + edge[i].cost;
                pre[v] = i;
                if(!vis[v])
                {
                    vis[v] = true;
                    q.push(v);
                }
            }
        }
    }
    if(pre[t] == -1)
        return false;
    return true;
}
void minCostmaxFlow(int s,int t)
{
    int flow = 0,cost = 0;
    while(Spfa(s,t))
    {
        int Min = inf;
        for(int i = pre[t];i != -1;i = pre[edge[i^1].to])
        {
            if(Min > edge[i].cap - edge[i].flow)
                Min = edge[i].cap - edge[i].flow;
        }
        for(int i = pre[t];i != -1;i = pre[edge[i^1].to])
        {
            edge[i].flow += Min;
            edge[i^1].flow -= Min;
            cost += edge[i].cost * Min;
        }
        flow += Min;
    }
    cout << flow << " " << cost << endl;
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n,m,s,t,c,w;
    cin >> n >> m;
    Init(n);
    for(int i = 0;i < m; i++)
    {
        cin >> s >> t >> c >> w;
        add_edge(s,t,c,w);
    }
    minCostmaxFlow(1,n);
    return 0;
}