网络流

最新推荐文章于 2023-02-06 20:18:15 发布
最新推荐文章于 2023-02-06 20:18:15 发布
阅读量812 收藏
点赞数
分类专栏： ◆学习笔记 【图论】

EK求最大流。复杂度O(n*m*m)。

EK求最大流。复杂度O(n*m*m)。
#include <queue>
#include <stdio.h>
#include <string.h>

using namespace std;

#define N 205
#define M 405
#define INF 0x7fffffff

#define min(a,b) a < b ?  a : b
#define CLR(a,v) memset(a,v,sizeof(a))

struct Vertex
{
    int head;
}V[N];

struct Edge
{
    Edge(){}
    Edge(int v,int c,int f,int ne):v(v),c(c),f(f),next(ne){}
}E[M];

int pre[N],flow[N];

int top,s,t;

void Init()
{
    top = 0;
    CLR(V,-1);
}

void Add_edge(int u,int v,int c)
{
    E[top] = Edge(v,c,0,V[u].head);
    V[u].head = top++;
    E[top] = Edge(u,0,0,V[v].head);
    V[v].head = top++;
}

bool Ed_Karp()
{
    CLR(flow,0);
    queue<int> Q;
    Q.push(s);
    flow[s] = INF;
    while(!Q.empty())
    {
        int u = Q.front();
        for(int i=V[u].head;i!=-1;i=E[i].next)
        {
            int v = E[i].v;
            if(!flow[v] && E[i].c > E[i].f)
            {
                pre[v] = i;
                flow[v] = min(flow[u],E[i].c-E[i].f);		//flow[v] represents the min flow in the way from "s" to "v".
                if(v == t)
                    return true;
                Q.push(v);
            }
        }
        Q.pop();
    }
    return false;
}

int Ford_Fulkerson()
{
    int i,MaxFlow = 0;
    while(Ed_Karp())
    {
        for(int v=t;v!=s;v=E[i^1].v)
        {
            i = pre[v];
            E[i].f   += flow[t];
            E[i^1].f -= flow[t];        //cool
        }
        MaxFlow += flow[t];
    }
    return MaxFlow;
}


SAP求最大流。复杂度O(n*n*m)。
#include <queue>
#include <stdio.h>
#include <string.h>

using namespace std;

#define N 205
#define M 40005
#define INF 0x7fffffff

#define min(a,b) a < b ?  a : b
#define CLR(a,v) memset(a,v,sizeof(a))

struct Vertex
{
    int head;
}V[N];

struct Edge
{
    int v,c,f,next;
    Edge(){}
    Edge(int v,int c,int f,int ne):v(v),c(c),f(f),next(ne){}
}E[M];

int d[N],pre[N],cur[N],gap[N];

int top,s,t,n;

void Init()
{
    top = 0;
    CLR(V,-1);
}

void Add_edge(int u,int v,int c)
{
    E[top] = Edge(v,c,0,V[u].head);
    V[u].head = top++;
    E[top] = Edge(u,0,0,V[v].head);
    V[v].head = top++;
}

void set_d()
{
    queue<int> Q;
    CLR(d,-1);
    CLR(gap,0);
    d[t] = 0;
    Q.push(t);
    while(!Q.empty())
    {
        int v = Q.front();
        Q.pop();
        ++gap[ d[v] ];
        for(int i=V[v].head;i!=-1;i=E[i].next)
        {
            int u = E[i].v;
            if(d[u] == -1)
            {
                d[u] = d[v]+1;
                Q.push(u);
            }
        }
    }
}

int Sap()
{
    set_d();                                        //You can replace it with "CLR(d,0)" if you feel it trouble
    int MaxFlow = 0, u = s;
    int flow = INF;
    memcpy(cur,V,sizeof(V));                        //current arc
    while(d[s] < n)
    {
        int &i = cur[u];                            //reference
        for(;i!=-1;i=E[i].next)
        {
            int v = E[i].v;
            if(E[i].c > E[i].f && d[u] == d[v]+1)  //admissible arc
            {
                u = v;
                pre[v] = i;
                flow = min(flow,E[i].c-E[i].f);
                if(u == t)
                {
                    while(u != s)
                    {
                        int j = pre[u];
                        E[j].f   += flow;
                        E[j^1].f -= flow;
                        u = E[j^1].v;
                    }
                    MaxFlow += flow;
                    flow = INF;
                }
                break;
            }
        }
        if(i == -1)                                //there's no admissible arc.
        {
            if(--gap[ d[u] ] == 0)
                break;
            int dmin = n-1;
            cur[u] = V[u].head;
            for(int j=V[u].head;j!=-1;j=E[j].next)
                if(E[j].c > E[j].f)                //not full arc
                    dmin = min(dmin,d[ E[j].v ]);
            d[u] = dmin+1;
            ++gap[ d[u] ];
            if(u != s)
                u = E[ pre[u]^1 ].v;
        }
    }
    return MaxFlow;
}

最小费用最大流。（最小费用路算法）复杂度O(n*m*MaxFlow)。
需要注意的地方：加反向边时，费用为真实费用的负值。
#include <queue>
#include <stdio.h>
#include <string.h>

using namespace std;

#define N 105
#define M 5205
#define INF 0x3fffffff

#define min(a,b) a < b ?  a : b
#define CLR(a,v) memset(a,v,sizeof(a))

struct Vertex
{
    int head;
}V[N];

struct Edge
{
    int v,c,f,cost,next;
    Edge(){}
    Edge(int v,int c,int f,int co,int ne):v(v),c(c),f(f),cost(co),next(ne){}
}E[M];

int pre[N],dis[N];

int top,s,t;

bool in[N];

void Init()
{
    top = 0;
    CLR(V,-1);
}

void Add_edge(int u,int v,int c,int cost)
{
    E[top] = Edge(v,c,0,cost,V[u].head);
    V[u].head = top++;
    E[top] = Edge(u,0,0,-cost,V[v].head);
    V[v].head = top++;
}

bool Spfa()
{
    CLR(dis,63);
    CLR(in,false);
    queue<int> Q;
    Q.push(s);
    dis[s] = 0;
    in[s] = true;
    while(!Q.empty())
    {
        int u = Q.front();
        for(int i=V[u].head;i!=-1;i=E[i].next)
        {
            int v = E[i].v;
            if(dis[u]+E[i].cost < dis[v] && E[i].c > E[i].f)
            {
                dis[v] = dis[u]+E[i].cost;
                pre[v] = i;
                if(!in[v])
                    Q.push(v);
                in[v] = true;
            }
        }
        Q.pop();
        in[u] = false;
    }
    return dis[t] != dis[N-1];
}

int Ford_Fulkerson()
{
    int i,MinCost = 0;
    while(Spfa())
    {
        int flow = INF;
        for(int v=t;v!=s;v=E[i^1].v)
        {
            i = pre[v];
            flow = min(flow,E[i].c-E[i].f);
        }
        for(int v=t;v!=s;v=E[i^1].v)
        {
            i = pre[v];
            E[i].f   += flow;
            E[i^1].f -= flow;
            MinCost += flow * E[i].cost;
        }
    }
    return MinCost;
}



SAP求最大流。复杂度O(n*n*m)。

#include <queue>
#include <stdio.h>
#include <string.h>

using namespace std;

#define N 205
#define M 40005
#define INF 0x7fffffff

#define min(a,b) a < b ?  a : b
#define CLR(a,v) memset(a,v,sizeof(a))

struct Vertex
{
    int head;
}V[N];

struct Edge
{
    int v,c,f,next;
    Edge(){}
    Edge(int v,int c,int f,int ne):v(v),c(c),f(f),next(ne){}
}E[M];

int d[N],pre[N],cur[N],gap[N];

int top,s,t,n;

void Init()
{
    top = 0;
    CLR(V,-1);
}

void Add_edge(int u,int v,int c)
{
    E[top] = Edge(v,c,0,V[u].head);
    V[u].head = top++;
    E[top] = Edge(u,0,0,V[v].head);
    V[v].head = top++;
}

void set_d()
{
    queue<int> Q;
    CLR(d,-1);
    CLR(gap,0);
    d[t] = 0;
    Q.push(t);
    while(!Q.empty())
    {
        int v = Q.front();
        Q.pop();
        ++gap[ d[v] ];
        for(int i=V[v].head;i!=-1;i=E[i].next)
        {
            int u = E[i].v;
            if(d[u] == -1)
            {
                d[u] = d[v]+1;
                Q.push(u);
            }
        }
    }
}

int Sap()
{
    set_d();                                        //You can replace it with "CLR(d,0)" if you feel it trouble
    int MaxFlow = 0, u = s;
    int flow = INF;
    memcpy(cur,V,sizeof(V));                        //current arc
    while(d[s] < n)
    {
        int &i = cur[u];                            //reference
        for(;i!=-1;i=E[i].next)
        {
            int v = E[i].v;
            if(E[i].c > E[i].f && d[u] == d[v]+1)  //admissible arc
            {
                u = v;
                pre[v] = i;
                flow = min(flow,E[i].c-E[i].f);
                if(u == t)
                {
                    while(u != s)
                    {
                        int j = pre[u];
                        E[j].f   += flow;
                        E[j^1].f -= flow;
                        u = E[j^1].v;
                    }
                    MaxFlow += flow;
                    flow = INF;
                }
                break;
            }
        }
        if(i == -1)                                //there's no admissible arc.
        {
            if(--gap[ d[u] ] == 0)
                break;
            int dmin = n-1;
            cur[u] = V[u].head;
            for(int j=V[u].head;j!=-1;j=E[j].next)
                if(E[j].c > E[j].f)                //not full arc
                    dmin = min(dmin,d[ E[j].v ]);
            d[u] = dmin+1;
            ++gap[ d[u] ];
            if(u != s)
                u = E[ pre[u]^1 ].v;
        }
    }
    return MaxFlow;
}


最小费用最大流。（最小费用路算法）复杂度O(n*m*MaxFlow)。

需要注意的地方：加反向边时，费用为真实费用的负值。

#include <queue>
#include <stdio.h>
#include <string.h>

using namespace std;

#define N 105
#define M 5205
#define INF 0x3fffffff

#define min(a,b) a < b ?  a : b
#define CLR(a,v) memset(a,v,sizeof(a))

struct Vertex
{
    int head;
}V[N];

struct Edge
{
    int v,c,f,cost,next;
    Edge(){}
    Edge(int v,int c,int f,int co,int ne):v(v),c(c),f(f),cost(co),next(ne){}
}E[M];

int pre[N],dis[N];

int top,s,t;

bool in[N];

void Init()
{
    top = 0;
    CLR(V,-1);
}

void Add_edge(int u,int v,int c,int cost)
{
    E[top] = Edge(v,c,0,cost,V[u].head);
    V[u].head = top++;
    E[top] = Edge(u,0,0,-cost,V[v].head);
    V[v].head = top++;
}

bool Spfa()
{
    CLR(dis,63);
    CLR(in,false);
    queue<int> Q;
    Q.push(s);
    dis[s] = 0;
    in[s] = true;
    while(!Q.empty())
    {
        int u = Q.front();
        for(int i=V[u].head;i!=-1;i=E[i].next)
        {
            int v = E[i].v;
            if(dis[u]+E[i].cost < dis[v] && E[i].c > E[i].f)
            {
                dis[v] = dis[u]+E[i].cost;
                pre[v] = i;
                if(!in[v])
                    Q.push(v);
                in[v] = true;
            }
        }
        Q.pop();
        in[u] = false;
    }
    return dis[t] != dis[N-1];
}

int Ford_Fulkerson()
{
    int i,MinCost = 0;
    while(Spfa())
    {
        int flow = INF;
        for(int v=t;v!=s;v=E[i^1].v)
        {
            i = pre[v];
            flow = min(flow,E[i].c-E[i].f);
        }
        for(int v=t;v!=s;v=E[i^1].v)
        {
            i = pre[v];
            E[i].f   += flow;
            E[i^1].f -= flow;
            MinCost += flow * E[i].cost;
        }
    }
    return MinCost;
}


nyist_xiaod
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[NetworkFlow]网络流建模相关
srand(time(0))
04-20 3137
网络流
网络流介绍
08-10
网络流是一种在图论中的概念，它用于模拟和分析网络中的流量分配问题。网络通常由节点（或顶点）和边组成，其中每个节点代表一个位置，每条边代表两个节点之间的连接。在网络流问题中，我们关注的是如何在满足某些...
最大流问题：增广路径算法的比较
weixin_34281537的博客
05-25 688
最大流问题：增广路径算法的比较 这篇文章我们将重温最大流问题，实现一些最有名的增广路径算法的实际分析的目标。我们将讨论的这几种算法的复杂度在O(n*m*m)到O(n*mlogU)之间，并且从讨论的结果中得到在实践中最有效的一种。正如我们所想的，理论上的复杂度并不能揭示该算法在实际中的价值。 这篇文章所针对的是熟悉网络流理论的基本知识的读...
MATLAB 网络流
小嗷犬的博客
02-06 2448
本文介绍了如何使用 MATLAB 解决最大流问题。
网络流——最大流
Wlis的博客
11-27 4578
一、什么是网络流 网络流是指给定一个有向图，其中有两个特殊的点：源点sss（Source）和汇点ttt（Sink）；每条边都有一个指定的流量上限，下文均称之为容量（Capacity），即经过这条边的流量不能超过容量，这样的图被称为网络流图。同时，除了源点和汇点外，所有点的入流和出流都相等，源点只有流出的流，汇点只有流入的流，网络流就是从 sss 到 ttt 的一个可行流。 二、可行流、最大流 定义...
网络流详解
AndrewLi的博客
12-02 4万+
network-flows，网络流，传说中的省选算法 先推荐一个讲网络流思路的网站： https://www.cnblogs.com/ZJUT-jiangnan/p/3632525.html 目的 首先，明确网络流是干什么的 给定指定的一个有向图,其中有两个特殊的点源S(Sources)和汇T(Sinks),每条边有指定的容量(Capacity),求满足条件的从S到T的最大流(MaxFlow)....
ffmpeg应用 接收网络流并解码播放
热爱生活，忠于自己
02-12 3457
文章目录1、ImageHandler模板类2、StreamDecoder类3、UdpServer类4、StreamApp类5、测试5.1、测试裸流数据保存5.2、回调方式获取图像5.3、轮询方式获取图像 前文 【ffmpeg学习（17）文件流、网络流的格式解析（使用AVIOContext ）】 和 【ffmpeg学习（19）文件流、网络流的格式解析（纯净版av_parser_parse2）】 介绍了使用文件模拟网络流解析并解码的过程。本文使用UDP socket通信实现真实的网络流通信。 下面是文件关系图：
网络流(一) 入门到熟练
热门推荐
在思索中前行！
03-21 4万+
一.网络流:流&amp;网络&amp;割 1.网络流问题(NetWork Flow Problem): 给定指定的一个有向图,其中有两个特殊的点源S(Sources)和汇T(Sinks),每条边有指定的容量(Capacity),求满足条件的从S到T的最大流(MaxFlow). 下面给出一个通俗点的解释 (下文基本避开形式化的证明 基本都用此类描述叙述) 好比你家是汇 自来水厂(有需要的同...
网络流（二） 最小费用最大流问题
Hello World!
10-13 6361
上篇我们讲解了最大流问题，那什么是最小费用最大流呢？听名字就可以看出，我们要在满足最大流的同时找到达成最大流的最小费用。对于一个网络流，最大流是一定的，但是组成最大流的费用是可以不同的，这里就有了在最大流网络上产生的费用流网络，就有了最小花费问题。
图论--网络流最大流问题
日拱一卒,功不唐捐
10-28 7919
问题表述：给定一幅图（n个结点，m条边），每一条边有一个容量，现在需要将一些物品从结点s（称为源点）运送到结点t（称为汇点），可以从其他结点中转，求最大的运送量。 在介绍最大流问题的解决方法之前，先介绍几个概念. 网络：网络是一个有向带权图，包含一个源点和一个汇点，没有反向平行边。 网络流：网络流即网上的流，是定义在网络边集E上的一个非负函数flow={flow（u，v）}, flow（u,...
无源汇有上下界可行流（网络流进阶）
Coco_T的博客
06-16 6479
无源汇有上下界可行流(也就是循环流)模型:一个网络,求出一个流,使得每条边的流量必须>=Li且<=Hi, 每个点必须满足总流入量=总流出量(流量守恒)(这个流的特点是循环往复,无始无终)可行流算法的核心是将一个不满足流量守恒的初始流调整成满足流量守恒的流流量守恒,即每个点的总流入量=总流出量如果存在一个可行流,那么一定满足每条边的流量都大于等于流量的下限 因此我们可以令每条边的流量等于流量下限,
网络流matlab代码(最大流).zip
07-11
网络流问题在图论和运筹学中是一个重要的理论模型，它被广泛应用于通信网络、运输规划、电路设计等多个领域。MATLAB作为一种强大的数学计算软件，提供了方便的环境来实现和解决这类问题。本压缩包包含的是利用MATLAB...
上下界网络流
04-16
"上下界网络流" 上下界网络流是一种特殊的网络流，边的流量有限制，必须在[down, up]的范围内。普通的网络流也是一种特殊的上下界网络流，只是每条边的流量限制为[0, cap]。上下界网络流可以分为两种：有源汇和无...
求大网络流的C++实现
12-22
　在这个工程中，网络上的点分为已标号点和未标号点。将起始点标号，其他刚开始未标号。从起始点开始，利用广度优先算法进行遍历，找到一个未标号点时，看临接的标号点与之是正向边还是反向边，以此来进行相应的...
网络流题集
09-02
网络流是一种在图论中的重要概念，用于解决各种优化问题，包括最大流、最小割、费用流等。在计算机科学和算法设计中，网络流问题经常出现于资源分配、运输规划、电路设计等多个领域。 1. **最大流**：最大流问题的...
探索算法迷宫：揭秘寻找最短路径的神兵利器
08-19
数据结构是计算机科学中的一个基本概念，它指的是数据的组织、管理和存储方式，以及对数据的操作。数据结构使得数据的访问和修改更加高效和有序。常见的数据结构包括： 1. **数组**（Array）：一种线性数据结构，可以存储相同类型的元素，并通过索引访问。 2. **链表**（Linked List）：一种线性数据结构，由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。 3. **栈**（Stack）：一种后进先出（LIFO, Last In First Out）的数据结构，只能在一端进行添加或删除操作。 4. **队列**（Queue）：一种先进先出（FIFO, First In First Out）的数据结构，允许在一端添加元素，在另一端删除元素。 5. **哈希表**（Hash Table）：通过键值对存储数据的数据结构，可以快速地通过键来访问数据。 6. **树**（Tree）：一种层次结构的数据结构，每个节点有零个或多个子节点，通常用于表示具有层次关系的数据。 7. **图**（Graph）：由顶点（节点）和边组成，可以表示复杂的关系和网络结构。 每种数据结构都有其
基于Android习惯养成APP设计与实现.docx
08-19
基于Android习惯养成APP设计与实现.docx
YOLO算法在生物信息学中的创新应用：从基因组到细胞成像
最新发布
08-19
YOLO（You Only Look Once）算法是一种流行的实时目标检测系统，通常用于计算机视觉领域。然而，其原理和效率同样适用于生物信息学领域，特别是在基因组学、蛋白质结构分析和细胞成像等方面。本文将探讨YOLO算法在生物信息学中的多种应用，包括基因组序列识别、蛋白质结构分类和细胞图像分析，并提供相应的代码示例。 YOLO算法在生物信息学领域展现出巨大的潜力，尤其是在需要快速和自动化分析的场景中。随着深度学习技术的不断进步，我们可以预见YOLO算法将在生物信息学中扮演越来越重要的角色。 参考文献 YOLO: Real-Time Object Detection Deep Learning for Bioinformatics 请注意，本文为示例性质，实际编写时需要根据具体主题和要求进行调整和补充。
知识分享辅助工具 - ObsidianPublishToCSDN-V1.1.py
08-19
知识分享辅助工具：ObsidianPublishToCSDN-V1.1.py 简介优化： 告别繁琐，拥抱高效！ObsidianPublishToCSDN-V1.1.py 是专为 Obsidian 用户打造的知识分享利器，旨在将您的笔记内容无缝对接至CSDN平台，让知识分享变得更加轻松快捷。 核心功能亮点： 智能图片提取：自动识别并收集Obsidian笔记中引用的所有图片，一键整理至指定文件夹，无需手动逐一查找，大幅提升发布效率。 Markdown优化转换：精准转换Obsidian的Markdown格式为CSDN兼容格式，保留原有排版与样式，确保内容呈现的专业与美观。 双链处理：特别针对Obsidian的双链特性，提供灵活处理方案，无论是转换为普通链接还是保留注释说明，均可按需配置，让内容更加适应CSDN环境。 高效文档生成：一键生成适用于CSDN发布的Markdown文档，减少手动编辑时间，让您的创意与知识更快触达读者。 持续迭代更新：本工具正处于活跃开发阶段，我们倾听每一位用户的反馈，不断优化功能，修复bug，确保为您提供最稳定、最便捷的使用体验。
网络流模型经典题解集合
"这篇文档是关于网络流问题的题解集合，涵盖了多个经典的网络流模型在实际问题中的应用。文档中列举了多个编程竞赛题目，包括最大流、最小割、有上下界的网络流以及最小费用流等不同类型的网络流问题，并提供了对应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值