最大流问题--FF与Dinic算法

最新推荐文章于 2022-12-26 08:58:10 发布
最新推荐文章于 2022-12-26 08:58:10 发布
阅读量177 收藏
点赞数
原文链接：http://www.cnblogs.com/Jonn-Liu/p/11511707.html
版权

// algorithm_FF.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"


#include <iostream>
#include <set>
#include <math.h>
#include <algorithm>

//Max stream FF算法
//Matrix  representation

#define inf INT_MAX

//#define N 5


int D[5][5] = { {0,4,6,inf,inf},
                {inf,0,2,3,inf},
                {inf,inf,0,inf,4},
             {inf, inf, inf, 0, 5},
            {inf,inf,inf,inf,0} };

#define N 6
int C[6][6] = { {0,8,12,inf,inf,inf},
                {inf,0,inf,6,10,inf},
                {inf,2,0,10,inf,inf},
             {inf, inf, inf,0, inf, 8},
            {inf,inf,inf,2,0,10},
            {inf,inf,inf,inf,inf,0    } };



struct Edge {
    int c;
    int f;
};
Edge edge[N][N];


int flag[N];//各点是否被标记
int prev[N];//前面一个节点是谁
int delta[N];//到j未止的最小值min（min(all(c-f)),min(f_)）
int chain[N];//

void init_edge(int mat[][N])//第二维开始要标记
{
    for (int i = 0; i < N;i++)
    {
        for (int j = 0; j < N; j++)
        {
            if (mat[i][j] != 0 and mat[i][j] < inf)
            {
                edge[i][j].c = mat[i][j];
                edge[i][j].f = 0;
            }
        }

    }

}


const int s = 0;//为什么被改了
const int t = 5;


//using namespace std;

void FF()
{
    
    while (1)
    {
        memset(flag, 0xff, sizeof(flag));//置为-1//表示是否标号.-1为标号,0为已标号未检查，1为标号已检查
        memset(prev, 0xff, sizeof(prev));//置为-1//
        memset(delta, 0xff, sizeof(delta));//置为-1
        flag[s] = 0;//
        prev[s] = 0;
        delta[s] = inf;
        int edge_head = -1;//Delta，书中大写三角形
        int  edge_tail = 0;
        chain[edge_tail] = s;


        while (edge_head < edge_tail)//第一次为0<1;1，3//BFS搜索
        {
            edge_head++;//第一次为1
            int i;
            i = chain[edge_head];//第一次为s，0，1，1//2，2//3，3//4，4//5，5.。/4，3节点//
            for (int j = 1; j < N; j++)
            {
                if (flag[j] == -1)//未被标记者
                {
                    if (edge[i][j].c < inf and edge[i][j].f < edge[i][j].c)//邻接且不饱和
                    {
                        flag[j] = 0;
                        prev[j] = i;
                        delta[j] = std::min(delta[i], edge[i][j].c - edge[i][j].f);
                        chain[++edge_tail] = j;//第一次为edge_tail=2,chain[2]=1;//二：3，2//内存泄露了这里改进了

                    }
                    else if (edge[j][i].c < inf and edge[j][i].f>0)//
                    {
                        flag[j] = 0;
                        prev[j] = -i;
                        delta[j] = std::min(delta[i], edge[j][i].f);
                        chain[++edge_tail] = j;//
                    }

                }
            }
            flag[i] = 1;//表示已经处理？？？？不知道

        }

        if (delta[t] == 0 or flag[t] == -1)//delta[t]=0表示，找不到增广链了出发不了即发点饱和了，flag[t]=-1表示中断了，到不了t了,即不存在增广路径了flag中没有了（已标号未检查）
            break;//结束了
        int k1 = t;
        int k0 = abs(prev[k1]);
        int a = delta[t];
        while (1)//回溯
        {
            if (edge[k0][k1].c < inf)
                edge[k0][k1].f += a;
            else if (edge[k1][k0].c < inf)
                edge[k1][k0].f -= a;
            if (k0 == s)
                break;
            k1 = k0;
            k0 = abs(prev[k1]);
        }
        delta[t] = 0;//新一轮开始



    }

    int f = 0;
    
    for (int j = 1; j < N; j++)
    {    
        if (edge[s][j].f < inf)
            {
                f += edge[s][j].f;
            }
    }
    
    std::cout << "maxflow" << f << std::endl;


}

int main()
{
    int f = 0;
    init_edge(C);
    FF();



    std::cout << "Hello World!\n";
}



/*

#include<vector>
#include <algorithm>
#define maxn 1200
#define INF 2e9
using namespace std;
int i, j, k, n, m, h, t, tot, ans, st, en;
struct node {
    int c, f;
}edge[maxn][maxn];
int flag[maxn], pre[maxn], alpha[maxn], q[maxn], v;
int read() {
    char c; int x; while (c = getchar(), c<'0' || c>'9'); x = c - '0';
    while (c = getchar(), c >= '0'&&c <= '9') x = x * 10 + c - '0'; return x;

}

//两个例子1// 6 9 1 6 1 2 8 1 3 12  2 4 6  2  5 10  3 2  2  3  4 10  4 6 8  5 4 2  5  6 10
//2//5 6 1 5 1 2 4 1 3 6 2 3 2 2 4 3 3 5 4 4 5 5




void bfs() {
    memset(flag, 0xff, sizeof(flag)); memset(pre, 0xff, sizeof(pre)); memset(alpha, 0xff, sizeof(alpha));
    flag[st] = 0; pre[st] = 0; alpha[st] = INF; h = 0, t = 1; q[t] = st;
    while (h < t) {
        h++; v = q[h];
        for (int i = 1; i <= n; i++) {
            if (flag[i] == -1) {
                if (edge[v][i].c < INF&&edge[v][i].f < edge[v][i].c) {
                    flag[i] = 0; pre[i] = v; alpha[i] = min(alpha[v], edge[v][i].c - edge[v][i].f); q[++t] = i;
                }
                else if (edge[i][v].c < INF&&edge[i][v].f>0) {
                    flag[i] = 0; pre[i] = -v; alpha[i] = min(alpha[v], edge[i][v].f); q[++t] = i;
                }
            }
        }
        flag[v] = 1;
    }
}

void Ford_Fulkerson() {
    while (1) {
        bfs();
        if (alpha[en] == 0 || flag[en] == -1) {
            break;
        }
        int k1 = en, k2 = abs(pre[k1]); int a = alpha[en];
        while (1) {
            if (edge[k2][k1].c < INF) edge[k2][k1].f += a;
            else if (edge[k1][k2].c < INF) edge[k1][k2].f -= a;
            if (k2 == st) break;
            k1 = k2; k2 = abs(pre[k1]);
        }
        alpha[en] = 0;
    }
}

void flow() {
    int maxflow = 0;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++) {
            if (i == st && edge[i][j].f < INF) maxflow += edge[i][j].f;
        }
    printf("%d", maxflow);
}

int main() {
    int u, v, c, f;
    n = read(); m = read(); st = read(); en = read();
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++) edge[i][j].c = INF, edge[i][j].f = 0;
    for (int i = 1; i <= m; i++) {
        u = read(); v = read(); c = read();
        edge[u][v].c = c;
    }
    Ford_Fulkerson();
    flow();
    return 0;
}
*/

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门提示:
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件

 

 

//Dinic

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;
#define inf 2e9
#define maxN 10005
#define maxM 100005
//#define N 5
/*

int C[5][5] = { {0,4,6,inf,inf},
                {inf,0,2,3,inf},
                {inf,inf,0,inf,4},
                {inf, inf, inf, 0, 5},
                {inf,inf,inf,inf,0} };



                */

//#define N 6
//const int s = 0;//
//const int t = 4;


int s;
int t;
int N;
int M;
/*
int C[6][6] = { {0,8,12,inf,inf,inf},
    {inf,0,inf,6,10,inf},
    {inf,2,0,10,inf,inf},
    {inf, inf, inf,0, inf, 8},
   {inf,inf,inf,2,0,10},
   {inf,inf,inf,inf,inf,0    } };


*/

int m = 0;
int cnt = 0;
vector<int > W, T;
vector<vector<int>> A(maxN);
void preprocess(vector<vector<int>> C)
{
    int ret = 0;
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            if (i != j and C[i][j] < inf)
            {
                ret++;
                int x = i; int y = j; int c = C[i][j];
                W.push_back(c);//W即C，C即W也
                T.push_back(y);//与cnt对应的
                A[x].push_back(cnt);//用于查找x出去的流量
                cnt++;
                W.push_back(0);
                T.push_back(x);//作为反向边也存下来
                A[y].push_back(cnt);//用于查找y出去的流量
                cnt++;




            }
        }
    }
    m = ret;
}



void input()
{
    cin>>N;
    cin>>M;
    cin>>s;
    cin>>t;
    s=s-1;
    t=t-1;
    int ret = M;
    for (int i = 0; i < M; i++)
    {


        int x, y;
        int  c;
        cin >> x >> y >> c;
        x=x-1;
        y=y-1;


        W.push_back(c);//W即C，C即W也
        T.push_back(y);//与cnt对应的
        A[x].push_back(cnt);//用于查找x出去的流量
        cnt++;
        W.push_back(0);
        T.push_back(x);//作为反向边也存下来
        A[y].push_back(cnt);//用于查找y出去的流量
        cnt++;


    }

}


int head = 0, tail = 0;


vector<int > chain(maxM*5, -1);
vector<int> dist(maxN, 0);
bool BFS()
{
    head = -1;
    tail = -1;
    chain[++tail] = s;
    fill(dist.begin(),dist.end(),0);
    dist[0] = 1;
    while (head < tail)
    {
        int i = chain[++head];
        for (int j = 0; j < A[i].size(); j++)
        {
            int y_cnt = A[i][j];
            if (dist[T[y_cnt]]==0 and W[y_cnt])
            {
                dist[T[y_cnt]] = dist[i] + 1;
                chain[++tail] = T[y_cnt];
            }
        }
    }
    return  dist[t];
}

int find(int cur, int  x)
{
    if (cur == t) return x;
    for (int j = 0; j < A[cur].size(); j++)
    {
        int y_index = A[cur][j];
        if (dist[T[y_index]] == dist[cur] + 1 && W[y_index])
        {
            int fd = find(T[y_index], min(x, W[y_index]));
            if (fd)
            {
                W[y_index] -= fd;
                W[y_index ^ 1] += fd;//y_index一定为偶数，^1就是加1
                return fd;
            }
        }
    }
    return 0;
}




int main()
{
    int f = 0;


    input();
    while (BFS() != 0) {
        f += find(s, inf);
    }
    cout << f;
    return 0;
}

转载于:https://www.cnblogs.com/Jonn-Liu/p/11511707.html

a19931225
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
网络流 最大流模板算法 FF算法 Dinic算法
aiwo1376301646的博客
02-10 480
介绍求最大流的两种常用算法：1：FF算法 2：Dinic算法 Dinic算法是FF算法的优化 这两篇代码可以作为自己求最大流的两种模板算法 配套题目，以题目为背景代入： https://www.luogu.com.cn/problem/P3376 1：FF算法 #include <bits/stdc++.h> using namespace std; const...
网络流之最大流——杨子曰算法
杨子曰：代码是神奇的
07-13 365
网络流之最大流（FF）——杨子曰算法 先上题：在一个国家里，有很多下水道（有向边），下水道都有自己能运输水的最大量，这些下水道把所有的n个城市都连在了一起，现在要从拥有无穷无尽水源的城市通过下水道，输送到城市n（除城市1外其他城市都没有水），问，最多能运输多少水？ 今天，我们来曰图论中一个高大上的算法——网络流——中的最大流。就是在一个有向图中，水流从一个点流向另一个点，能流过去的水流量。...
网络流-最大流(Ford-Fulkerson算法&Dinic算法)
qq_36102055的博客
07-14 549
#include<bits/stdc++.h> #define INF 0x3f3f3f3f using namespace std; const int maxn = 1e5 + 5; int n,m,cnt = 2,h[maxn]; int st,ed; bool vis[maxn]; struct node{ int w,e,nex; }e[maxn * 2]; void add(int a,int b,int c){ e[cnt].e = b; e[cnt].nex = h[a]; e[
网络流_2_FF方法_EK算法与DINIC算法
m0_51780913的博客
11-02 426
网络流__2 EK 算法与Dinic算法 FORD-FULKERSON算法 维护一个残留网络，不断地迭代找增广路，将增广路删除后得到新的残留网络中继续迭代，直到某次迭代中找不到增广路时，此时当前流为最大流 FORD-FULKERSON(G,s,t) for each edge(u,v) in G.E: (u,v).f=0 while there exits a path p from s to t in the residual network Gf: #当存在残留网络 Cf(p)=min{Cf(
网络流及几种算法FF、EK、Dinic
最新发布
ComingLiu的博客
12-26 730
网络流
图论- 网络流- 最大流- Dinic 算法.rar
09-16
Dinic于1970年提出的求解最大流问题的有效算法，它的主要特点是基于层的概念和增广路径的思想。下面我们将深入探讨Dinic算法的基本原理和步骤。 1. **初始化**：首先定义源点s和汇点t，将所有边的容量设为边上的...
network-flow:最大流的 Dinic 算法的 C++ 实现
06-04
最大流的 Dinic 算法的 C++ 实现。 以下是操作摘要： FlowNetwork f(n, m) ：具有 n 个顶点（0 到 n-1）和 m 个有向边的新网络， f.add(x, y, c) ：添加从节点 x 到节点 y 的有向边，容量为 c， f.flow(s, t) ：...
最大网络流Dinic算法
09-01
总结起来，Dinic算法是解决最大网络流问题的一种高效方法，通过层次结构和增广路径的概念，能够在保证正确性的前提下，实现较好的运行效率。在实际应用中，它可以用于解决资源分配、调度、通信网络流量规划等问题。
最大流dinic算法
12-06
Dinic算法的基本思路: 1.根据残量网络计算层次图。 2.在层次图中使用DFS进行增广直到不存在增广路 3.重复以上步骤直到无法增广
网络流最大流Dinic算法代码
10-16
最大流的Dinic算法，时间复杂度O(EV^2),代码简单而高效
网络流之最大流算法总结（FF， EK， Dinic）
张宜强的博客
11-26 6367
目录 FF算法：最基础的最大流算法 EK算法：每次BFS寻找増广路 Dinic算法：EK算法的优化 Dinic+链式前向星 这里以POJ1273这道题为例，题目链接：http://poj.org/problem?id=1273 FF算法：最基础的最大流算法 通过DFS増广，直到不能増广为止。 记最大流的流量为F，FF算法最多进行F次DFS，所以其复杂度为O(F|E|)，每一次DFS...
网络流最大流（FF、Dinic）详解
weixin_43945141的博客
11-23 3140
网络流基础概念 考虑这幅图，你可以看成从村庄s到村庄t有很多条物流道路，每个点都是个中转结点，每条路的权值即该条路最多能运送的货物 介绍一些基本概念： 网络：一个入度为0的点s，一个出度为0的点t，每条边有自己权值的有向图 容量：当前边上的权值，比如SA的容量即为3 源点：入度为0的点，通常s来表示 汇点：出度为0的点，通常t来表示 流：一个合法解称作一个流，也就是一条可以从源点到汇点的一条合法路径。 流量：每条边各自运送的包裹数称作其流量，最终收集的总数为整个流的流量。边上的流量：f（SA）=2，代表今
网络流算法学习笔记——Dinic有效算法
zhang35的博客
04-27 1079
Dinic有效算法同样用来求最大流，相当于FF算法的改进。 FF算法参考：网络流算法学习笔记——最大流问题基本概念和Ford-Fulkerson方法（标号法C++实现） 改进之处有： FF算法每次只找1条s-t增广链，而Dinic算法每次能找很多条 Dinic算法每次都找最短的（边数最少的）s-t增广链（为啥呢？ ） ...
FF最大流问题算法
qq_35608277的博客
11-23 4302
一、最大流问题 最大流问题(maximum flow problem)，一种组合最优化问题，就是要讨论如何充分利用装置的能力，使得运输的流量最大，以取得最好的效果。 实际来源： 有一个自来水管道运输系统，起点是 s，终点是 t，途中经过的管道都有一个最大的容量，可以想象每条管道不能被水流“撑爆”。求从 s 到 t 的最大水流量是多少？ 数学模型 性质1：容量限制(Capacity Constra...
CTF逆向总结（二）
沐一 · 林 的博客
10-21 5910
CTF 逆向总结 非预期行为： 指解题中出现与预想结果不符合的一系列非预期行为，这基本说明了在中间或前面存在其他自己还没分析的操作。 不同系统的特殊数： 指解题中遇到考察特定位数系统中特定的数的真实值的时候，需要辨认出对应的值才能继续解题。如：32位系统中100000000就是0了 冗余中锁定关键代码： 从后往前看，就是确定比较关键对象，从该对象开始排除其他无关变量，一步步找出与该对象有关的其它变量，最后串起找到的所有相关变量，然后开始逆向分析。 题目类型总结： 题目描述
网络流之最大流(FF, EK, Dinic, SAP)
yo_bc的博客
05-31 4494
对于Gap优化成立的解释： 假如某次修改d[u]后第一次出现断层k，显然d[u]之前是等于k的，而d[u]修改的原因是修改前d[u] < d[v]+1，所以d[v] > k-1,而因为出现断层k，d[v] != k，故d[v] 〉 k。而由于d函数时单调递增的，所以这个空缺永远不会被填补。而你可能会想会不会存在存在若干个层次k-1的点和层次k+1的点能填补这个空缺？答案是否定的，因为假如存在层次k-1的点和层次k+1的点连边，那么层次k+1的这个点的存在是不合适的，因为不管是初始时候或者是之后修改层次的原因
最大流的基本算法（ff算法&&dinic算法&&push-rebeal算法）poj1273
aaron_1996的专栏
08-08 3026
最大流的基本概念有以下几点：               1.残存网络：即为一条管道被占用了一部分流量之后所剩下的流量。在网络流中，图被看为一个有向图，残存流量向量相加后永远不变。这一点有点像基尔霍夫定律。               2.在找到一个流之后，仍然存在的从源点到汇点的路径。这叫做增广路径。加入增广路径后，流的容量一定能够提升。寻找增广路径一般使用DFS或BFS。 ford-fu
最大流（最小割） FF算法，EK算法，Dinic算法（模板） + poj 1273
Rshs
03-15 799
挑战程序设计209 http://poj.org/problem?id=1273 三个算法的时间都是16ms（数据没有刻意去卡吧） FF 算法和 EK算法 原理相似，至于为什么EK算法复杂度的解释不错 ： https://blog.csdn.net/weixin_40673608/article/details/86707598 FF 算法，复杂度最高为O（FE） （实际会低很多）...
求最大流的两种算法 EK算法和dinic算法
qq_40938077的博客
05-21 2858
我们接下来讲的都是按照这个图来讲的   EK算法 算法思想，基本流程： 通过广搜函数寻找增广路，然后函数返回的是找到的增广路中权值最小的值，如果找不到增广路，返回0。然后运用广搜函数返回的值更新邻接矩阵中的值。每次都把广搜函数返回的值累加，直到图中不存在增广路为止，累加的结果就是最大流。 代码如下： #include&lt;bits/stdc++.h&gt; #define MA...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值