各种网络流模板整合(EK,Dinic,推送-重贴标签,前置重贴标签)

最新推荐文章于 2023-05-16 23:58:37 发布
最新推荐文章于 2023-05-16 23:58:37 发布
阅读量742 收藏 8
点赞数 1
分类专栏： 模板 图论-网络流 文章标签： 网络流 模板 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hardict/article/details/84378049
版权

本文不涉及讲解,仅罗列各种算法模板(都是自己写的,不一定最优,且一个算法不一定只有一种)——不定期更新

目录

  • Edmond-Karp(O(VE^2))——包含邻接矩阵,邻接表,储存边三种
  • Dinic(O(V^2E))——包含基础与当前弧优化两种
  • 推送重贴标签(O(V^2E))——一种
  • 前置重贴标签(O(V^3))——一种
  • 注:最后两种来自与《算法导论》,不一定保证最优实现，且该两种算法下界大致为\Omega (V^2)，故要谨慎使用！！(以及残存容量实时更新,不单独计算并允许双向边存在)

Edmond-Karp算法

1.邻接链表(第一次写网络流的最好尝试)

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

int N, M, st, se;
int cap[205][205], pre[205];
bool vis[205];
int Edmonds_Karp(int s, int t);

int main(){
  ios::sync_with_stdio(false);
  int i;
  cin >> N >> M >> st >> se;
  for(i = 1; i <= M; i++){
    int x, y, w;
    cin >> x >> y >> w;
    cap[x][y] = w;
  }
  cout << Edmonds_Karp(st, se) << endl;
  return 0;
}

bool bfs(int s, int t);//寻找残存网络中最短增广路
int Edmonds_Karp(int s, int t){
  int i, cf_min, max_flow;
  max_flow = 0;
  while(bfs(s, t)){
    cf_min = 1e9 + 7;
    for(i = t; i != s; i = pre[i])
      cf_min = min(cf_min, cap[pre[i]][i]);
    for(i = t; i != s; i = pre[i]){
      cap[pre[i]][i] -= cf_min;
      cap[i][pre[i]] += cf_min;
    }
    max_flow += cf_min;
  }
  return max_flow;
}

bool bfs(int s, int t){
  int i;
  memset(vis, 0, sizeof(vis));
  queue<int> Q;
  Q.push(s), vis[s] = true;
  while(!Q.empty()){
    auto u = Q.front(); Q.pop();
    for(i = 1; i <= N; i++){
      if(!vis[i] && cap[u][i] > 0){
        Q.push(i), vis[i] = true;
        pre[i] = u;
        if(i == t) return true;
      }
    }
  }
  return false;
}

2.邻接表

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

const int MAXN = 1e4 + 5;
const int MAXM = 1e5 + 5;
struct edge {
  int next, now, to, c;
} e[MAXM * 2];
int head[MAXN], cnt_adj;
void add_edge(int x, int y, int z);
int N, M, st, se;
int Edmonds_Karp(int s, int t);

int main(){
  ios::sync_with_stdio(false);
  int i;
  cin >> N >> M >> st >> se;
  cnt_adj = 1;
  for(i = 1; i <= M; i++){
    int x, y, z;
    cin >> x >> y >> z;
    add_edge(x, y, z);
    add_edge(y, x, 0);
  }
  cout << Edmonds_Karp(st, se) << endl;
  return 0;
}

int pre[MAXN];
bool EK_bfs(int s, int t);
int Edmonds_Karp(int s, int t){
  int maxflow = 0;
  while(EK_bfs(s, t)){
    int i, cf_min = 1e9 + 7;
    for(i = pre[t]; i; i = pre[e[i].now]){
      cf_min = min(cf_min, e[i].c);
    }
    for(i = pre[t]; i; i = pre[e[i].now]){
      e[i].c -= cf_min;
      e[i ^ 1].c += cf_min;
    }
    maxflow += cf_min;
  }
  return maxflow;
}

bool vis[MAXN];
bool EK_bfs(int s, int t){
  memset(vis, 0, sizeof(vis));
  int i;
  queue<int> Q;
  Q.push(s), vis[s] = true;
  while(!Q.empty()){
    int u = Q.front(); Q.pop();
    for(i = head[u]; i; i = e[i].next){
      int v = e[i].to, cf = e[i].c;
      if(!vis[v] && cf){
        Q.push(v), vis[v] = true;
        pre[v] = i;
        if(v == t) return true;
      }
    }
  }
  return false;
}

void add_edge(int x, int y, int z){
  e[++cnt_adj].to = y;
  e[cnt_adj].now = x;
  e[cnt_adj].c = z;
  e[cnt_adj].next = head[x];
  head[x] = cnt_adj;
}

3.储存边

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;

const int MAXN = 1e4 + 5;
const int MAXM = 1e5 + 5;
//储存边与对于顶点的反向hash
struct node {
  int u, v, c;
} e[MAXM * 2];
vector<int> hash_e[MAXN];
int N, M, st, se;
int pre[MAXN];
bool vis[MAXN];
int Edmonds_Karp(int s, int t);

int main(){
  ios::sync_with_stdio(false);
  int i, j;
  cin >> N >> M >> st >> se;
  for(j = 0; j < M; j++){
    i = 2 * j;
    int x, y, z;
    cin >> x >> y >> z;
    e[i].u = x, e[i].v = y, e[i].c = z;
    e[i ^ 1].u = y, e[i ^ 1].v = x;
    hash_e[x].push_back(i);
    hash_e[y].push_back(i ^ 1);
  }
  cout << Edmonds_Karp(st, se) << endl;
  return 0;
}

bool EK_bfs(int s, int t);
int Edmonds_Karp(int s, int t){
  int i, cap_min, maxflow;
  maxflow = 0;
  while(EK_bfs(s, t)){
    cap_min = 1e9 + 7;
    for(i = t; i != s; i = e[pre[i]].u)
      cap_min = min(cap_min, e[pre[i]].c);
    for(i = t; i != s; i = e[pre[i]].u){
      e[pre[i]].c -= cap_min;
      e[pre[i] ^ 1].c += cap_min;
    }
    maxflow += cap_min;
  }
  return maxflow;
}

bool EK_bfs(int s, int t){
  memset(vis, 0, sizeof(vis));
  int i, j;
  queue<int> Q;
  Q.push(s), vis[s] = true;
  while(!Q.empty()){
    auto u = Q.front(); Q.pop();
    for(i = 0; i < (int)hash_e[u].size(); i++){
      j = hash_e[u][i];
      int v = e[j].v;
      if(!vis[v] && e[j].c > 0){
        Q.push(v), vis[v] = true;
        pre[v] = j;
        if(v == t) return true;
      }
    }
  }
  return false;
}

Dinic算法

1.基本写法

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

const int MAXN = 1e4 + 5;
const int MAXM = 1e5 + 5;
struct edge {
  int next, to, c;
} e[MAXM * 2];
int head[MAXN], cnt_adj;
void add_edge(int, int, int);
int N, M, st, se;
int Dinic(int s, int t);

int main(){
  ios::sync_with_stdio(false);
  int i;
  cin >> N >> M >> st >> se;
  cnt_adj = 1;//2i-1与2i对应一组边,从2开始(不可从0)
  for(i = 1; i <= M; i++){
    int x, y, z;
    cin >> x >> y >> z;
    add_edge(x, y, z);
    add_edge(y, x, 0);
  }
  cout << Dinic(st, se) << endl;
  return 0;
}

int dep[MAXN];
bool Dinic_bfs(int s, int t);
int Dinic_dfs(int u, int cf_min, int t);
int Dinic(int s, int t){
  int max_flow = 0;
  while(Dinic_bfs(s, t))
    while(int val = Dinic_dfs(s, 1e9 + 7, t))
      max_flow += val;
  return max_flow;
}

//分层
bool Dinic_bfs(int s, int t){
  int i;
  memset(dep, 0, sizeof(dep));
  queue<int> Q;
  Q.push(s), dep[s] = 1;
  while(!Q.empty()){
    auto u = Q.front(); Q.pop();
    //cout << u << endl;
    for(i = head[u]; i; i = e[i].next){
      int v = e[i].to, cf = e[i].c;
      //cout << v << " " << cf << endl;
      if(cf > 0 && !dep[v]){
        dep[v] = dep[u] + 1;
        Q.push(v);
      }
    }
    //cout << endl;
  }
  //cout << endl;
  if(!dep[t]) return false;
  return true;
}

int Dinic_dfs(int u, int cf_min, int t){
  if(u == t) return cf_min;
  int i;
  for(i = head[u]; i; i = e[i].next){
    int v = e[i].to, cf = e[i].c;
    if(dep[v] == dep[u] + 1 && cf > 0){
      int val = Dinic_dfs(v, min(cf_min, cf), t);
      if(val > 0){//增广成功
        e[i].c -= val;
        e[i ^ 1].c += val;
        return val;
      }
    }
  }
  return 0;
}

void add_edge(int x, int y, int z){
  e[++cnt_adj].to = y;
  e[cnt_adj].c = z;
  e[cnt_adj].next = head[x];
  head[x] = cnt_adj;
}

2.当前弧优化

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

const int MAXN = 1e4 + 5;
const int MAXM = 1e5 + 5;
struct edge {
  int next, to, c;
} e[MAXM * 2];
int head[MAXN], cnt_adj;
void add_edge(int x, int y, int z);
int N, M, st, se;
int Dinic(int s, int t);

int main(){
  ios::sync_with_stdio(false);
  int i;
  cin >> N >> M >> st >> se;
  cnt_adj = 1;
  for(i = 1; i <= M; i++){
    int x, y, z;
    cin >> x >> y >> z;
    add_edge(x, y, z);
    add_edge(y, x, 0);
  }
  cout << Dinic(st, se) << endl;
  return 0;
}

int dep[MAXN], cur[MAXN];
bool Dinic_bfs(int s, int t);
int Dinic_dfs(int u, int cf_min, int t);
int Dinic(int s, int t){
  int maxflow = 0;
  while(Dinic_bfs(s, t)){
    int i, val;
    for(i = 1; i <= N; i++)
      cur[i] = head[i];
    while((val = Dinic_dfs(s, 1e9 + 7, t)))
      maxflow += val;
  }
  return maxflow;
}

bool Dinic_bfs(int s, int t){
  int i;
  memset(dep, 0, sizeof(dep));
  queue<int> Q;
  Q.push(s), dep[s] = 1;
  while(!Q.empty()){
    auto u = Q.front(); Q.pop();
    for(i = head[u]; i; i = e[i].next){
      int v = e[i].to, cf = e[i].c;
      if(cf > 0 && !dep[v]){
        dep[v] = dep[u] + 1;
        Q.push(v);
      }
    }
  }
  if(!dep[t]) return false;
  return true;
}

int Dinic_dfs(int u, int cf_min, int t){
  if(u == t || !cf_min) return cf_min;
  for(int &i = cur[u]; i; i = e[i].next){//取地址进行操作,实时更新
    int v = e[i].to, cf = e[i].c;
    if(cf > 0 && dep[v] == dep[u] + 1){
      int val = Dinic_dfs(v, min(cf_min, cf), t);
      if(val > 0){
        e[i].c -= val;
        e[i ^ 1].c += val;
        return val;
      }
    }
  }
  return 0;
}

void add_edge(int x, int y, int z){
  e[++cnt_adj].to = y;
  e[cnt_adj].c = z;
  e[cnt_adj].next = head[x];
  head[x] = cnt_adj;
}

推送-重贴标签

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

struct edge {
  int next, to, c;
} e[200005];
int head[10005], cnt_adj;
void add_edge(int x, int y, int z);
int N, M, st, se;
int Push_and_Relabel(int s, int t);

int main(){
  ios::sync_with_stdio(false);
  int i;
  cin >> N >> M >> st >> se;
  cnt_adj = 1;
  for(i = 1; i <= M; i++){
    int x, y, z;
    cin >> x >> y >> z;
    add_edge(x, y, z);
    add_edge(y, x, 0);
  }
  cout << Push_and_Relabel(st, se) << endl;
  return 0;
}

struct node {
  int h, e;
} p[10005];
void Init_Preflow(int s);
int check(int s, int t);
bool Push(int u);
void Relabel(int u);
int Push_and_Relabel(int s, int t){
  int id;
  Init_Preflow(s);
  while((id = check(s, t))){
    if(!Push(id))
      Relabel(id);
  }
  return p[t].e;
}

int check(int s, int t){
  int i;
  for(i = 1; i <= N; i++)
    if(i != s && i != t && p[i].e)
      return i;
  return 0;
}

void Init_Preflow(int s){
  int i;
  p[s].h = N;
  for(i = head[s]; i; i = e[i].next){
    int val = e[i].c;
    p[s].e -= val;
    p[e[i].to].e += val;
    e[i].c -= val;
    e[i ^ 1].c += val;
  }
}

bool Push(int u){
  bool flag = false;
  int i;
  for(i = head[u]; i; i = e[i].next){
    int v = e[i].to, cf = e[i].c;
    if(cf && p[u].h == p[v].h + 1){
      int val = min(p[u].e, cf);
      p[u].e -= val;
      p[v].e += val;
      e[i].c -= val;
      e[i ^ 1].c += val;
      flag = true;
    }
  }
  return flag;
}

void Relabel(int u){
  int i, minn = 1e9 + 7;
  for(i = head[u]; i; i = e[i].next){
    int v = e[i].to, cf = e[i].c;
    if(cf)
      minn = min(minn, p[v].h);
  }
  if(minn == 1e9 + 7)
    minn = -1;
  p[u].h = minn + 1;
}

void add_edge(int x, int y, int z){
  e[++cnt_adj].to = y;
  e[cnt_adj].c = z;
  e[cnt_adj].next = head[x];
  head[x] = cnt_adj;
}

前置重贴标签

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

const int MAXN = 1e4 + 5;
const int MAXM = 1e5 + 5;
struct edge {
  int next, to, c, f, cf;
} e[MAXM * 2];
int head[MAXN], cnt_adj;
void add_edge(int x, int y, int z);
int N, M, st, se;
int height[MAXN], overflow[MAXN];
void Relabel_to_Front(int s, int t);

int main(){
  ios::sync_with_stdio(false);
  int i;
  cin >> N >> M >> st >> se;
  cnt_adj = 1;
  for(i = 1; i <= M; i++){
    int x, y, z;
    cin >> x >> y >> z;
    add_edge(x, y, z);
    add_edge(y, x, 0);
  }
  Relabel_to_Front(st, se);
  //for(i = 1; i <= N; i++)
  //  cout << overflow[i] << endl;
  cout << overflow[se] << endl;
  return 0;
}

struct linklist {
  int val;
  linklist *next, *pre;
};
void Discharge(int u);
void Init_Preflow(int s);
void Relabel_to_Front(int s, int t){
  Init_Preflow(s);
  int i;
  linklist *head = new linklist;
  linklist *NIL = new linklist;
  head->next = head->pre = NIL;
  head->val = NIL->val = -1;
  for(i = 1; i <= N; i++)
    if(i != s && i != t){
      linklist *x = new linklist;
      x->val = i;
      x->next = head->next;
      x->pre = head;
      x->next->pre = x;
      head->next = x;
    }

  linklist *p = head->next;
  while(p->val != -1){
    int u = p->val;
    int old_height = height[u];
    Discharge(u);
    if(old_height < height[u]){
      p->pre->next = p->next;
      p->next->pre = p->pre;

      p->next = head->next;
      p->pre = head;
      p->next->pre = p;
      head->next = p;
    }
    p = p->next;
  }
}

void Init_Preflow(int s){
  int i;
  //memset(height, 0, sizeof(height));
  //memset(overflow, 0, sizeof(overflow));
  //init e.f=0;
  height[s] = N;
  for(i = head[s]; i; i = e[i].next){
    int val = e[i].c;
    e[i].f = val;
    overflow[s] -= val;
    overflow[e[i].to] += val;
    e[i].c -= val;
    e[i ^ 1].c += val;
  }
  //for(i = 1; i <= N; i++)
  //  cout << overflow[i] << endl;
}

void Push(int u, int id);
void Relabel(int u);
void Discharge(int u){
  int i;
  i = head[u];
  if(!i) return;
  while(overflow[u]){
    if(!i){
      Relabel(u);
      i = head[u];
    }else{
      int v = e[i].to, cf = e[i].c;
      if(cf && height[u] == height[v] + 1)
        Push(u, i);
      i = e[i].next;
    }
  }
}


void Push(int u, int id){
  int val = min(overflow[u], e[id].c);
  e[id].c -= val;
  e[id ^ 1].c += val;
  overflow[u] -= val;
  overflow[e[id].to] += val;
}

void Relabel(int u){
  int i, minn = 1e9 + 7;
  for(i = head[u]; i; i = e[i].next){
    int v = e[i].to, cf = e[i].c;
    if(cf)
      minn = min(minn, height[v]);
  }
  if(minn == 1e9 + 7) minn = -1;
  height[u] = minn + 1;
}

void add_edge(int x, int y, int z){
  e[++cnt_adj].to = y;
  e[cnt_adj].c = z;
  e[cnt_adj].next = head[x];
  head[x] = cnt_adj;
}

 

Hardict
关注
专栏目录
算法导论 最大流 前置重贴标签法
苦海无涯闯进来
08-22 1364
1
最大流学习笔记（3）-推送重贴标签算法一
weixin_33972649的博客
10-30 523
上一篇 1 预流：预流是一个$V\times V \rightarrow R$的函数$f$，该函数对于每个节点$u\in V-\{s\}$满足容量限制条件和下面的性质： $\sum_{v\in V}f(v,u)-\sum_{v\in V}f(u,v)\geq 0$ 定义$e(u)=\sum_{v\in V}f(v,u)-\sum_{v\in V}f(u,v)$为进入节点$u$的超额流...
最大流学习笔记（4）-推送重贴标签算法二
weixin_34148340的博客
10-30 193
上一篇 14 设$f$是流网络G的一个预流，那么对于任意一个溢出节点$x$，在$G_{f}$中存在一条从$x$到源点$s$的简单路径。 15 在GENERIC-PUSH-RELABEL的整个过程中，任何一个$u\in V$，$u.h\leq 2|V|-1$ 16 在GENERIC-PUSH-RELABEL的整个过程中,每个节点被重贴标签次数最多为$2|V|-1$，所有重贴...
最大流学习笔记（6）-前置重贴标签算法二
weixin_33699914的博客
11-02 175
上一篇 8、前置重贴标签操作算法流程：将维护一个链表$L$,该表由$V-\{s,t\}$中的所有节点构成，$L$中的节点的顺序将按照许可网络中的拓扑排序存放。$u.next$是链表$L$的下一个节点。下面是算法的伪代码： 9、 为了证明RELABEL-TO-FRONT确定计算出了一个最大流，下面将证明该算法就是GENERIC-PUSH-RELABEL的一种实现。首先，7证明了推...
最大流学习笔记（5）-前置重贴标签算法一
weixin_33877885的博客
11-01 220
上一篇 1、许可边：设$f$是流网络G的一个预流，$h$是高度函数。对于边$(u,v)$，如果$c_{f}(u,v)>0$且$h(u)=h(v)+1$，那么边$(u,v)$是一个许可边。否则是非许可边。许可网络$G_{f,h}=(V,E_{f,h})$,$E_{f,h}$是许可边的集合 2、许可网络是有向无环的。因为对于每条许可边$(u,v)$来说，$h(u)=h(v)+1$...
网络流dinic模板
02-24
网络流dinic模板，非本人原创。网络流dinic模板，非本人原创
最大流模板.cpp dinic
02-08
最大流模板.cpp dinic
网络流Dinic
02-01
### 网络流Dinic算法详解 #### 一、引言 在计算机科学与图论领域中，网络流问题是一类重要的优化问题，旨在寻找一个网络中的最大流量。Dinic算法是解决这类问题的一种高效算法，它通过构建增广路径来逐步增加网络...
Dinic算法--挺有用的
05-07
Dinic算法--挺有用的，希望对在学习Dinic算法的人或对之感兴趣的人有所帮助！
网络流最大流Dinic算法代码
10-16
最大流的Dinic算法，时间复杂度O(EV^2),代码简单而高效
贴标签算法
05-16
对二值图像的目标区域进行标记。
网络流-推送-重贴标签算法
dgr42861的博客
07-19 720
网络流的推送-重贴标签算法代码 1 #include<iostream> 2 #include<algorithm> 3 using namespace std; 4 struct pointtype{ 5 int e; 6 int h; 7 }point[1001]; 8 int map[1001][1001]...
【Algorithm】Push-Relabel算法
Esperanto.的博客
04-08 2678
最大流问题 Push-Relabel算法
贴标签
Donald_TY的专栏
08-24 599
罗老师正在给一堆球贴标签，总共有N个球，要给他们贴1-N的编号，不能重复。 罗老师首先将这N个球排成一排，排好后，突然想给自己找点麻烦（无聊），就想出了M条限制条件，每个条件是： A B 表示第A个球的编号要小于第B个球的编号。 当然，限制条件会造成有时答案有很多种，那么罗老师希望贴好标签后的球字典序最小；也有可能答案不存在，那么就输出-1。输入 首先输入T，表示有T组测试数据 然后
ACM竞赛算法知识导图（会继续补充）
最新发布
wangyubo_20040617的博客
05-16 1638
竞赛算法大纲
《推荐系统开发实战》之基于标签的推荐算法介绍和案例实战开发
Thinkgamer博客
07-15 4103
转载请注明出处：http://blog.csdn.net/gamer_gyt 博主微博：http://weibo.com/234654758 Github：https://github.com/thinkgamer 公众号：搜索与推荐Wiki 个人网站：http://thinkgamer.github.io 标签系统的传统用法是，在一些网站中，用户会为自己感兴趣的对象打上一些标签，如豆瓣、网易...
算法系列笔记10(有关图的算法三—最大流与二分图)
小村长技术blog
03-15 3763
本次主要记录流网络以及最大流的简单概念(以后可能会将最大流的实现算法补充)，重点讲解用匈牙利算法来求二分图的最大匹配。 1：流网络 流网络是G(V, E)是一个有限的有向图，它的每条边(u, v) ∈E都有一个非负值实数的容量c(u, v)≥0。如果(u, v) 不属于E，我们假设c(u, v) = 0。我们区别两个顶点：一个源点s和一个汇点t.。并假定每个顶点均处于从源点到汇点的某条路
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值