有上下界的可行流，最大流，最小流（模板题）

最新推荐文章于 2022-03-20 20:01:29 发布
最新推荐文章于 2022-03-20 20:01:29 发布
阅读量185 收藏
点赞数 1
分类专栏： Network Flow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c337134154/article/details/102248935
版权

目录

Loj #115 无源汇有上下界可行流

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

const int maxn = 200 + 10;
const int INF = 1000000000;

struct Edge {
  int from, to, cap, flow, lb;
};

bool operator < (const Edge& a, const Edge& b) {
  return a.from < b.from || (a.from == b.from && a.to < b.to);
}

struct Dinic {
  int n, m, s, t;
  vector<Edge> edges;    // 边数的两倍
  vector<int> G[maxn];   // 邻接表，G[i][j]表示结点i的第j条边在e数组中的序号
  bool vis[maxn];         // BFS使用
  int d[maxn];           // 从起点到i的距离
  int cur[maxn];        // 当前弧指针

  void ClearAll(int n) {
    for(int i = 0; i < n; i++) G[i].clear();
    edges.clear();
  }

  void ClearFlow() {
    for(int i = 0; i < edges.size(); i++) edges[i].flow = 0;
  }

  void AddEdge(int from, int to, int cap, int lb) {
    edges.push_back((Edge){from, to, cap, 0, lb});
    edges.push_back((Edge){to, from, 0, 0, lb});
    m = edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
  }

  bool BFS() {
    memset(vis, 0, sizeof(vis));
    queue<int> Q;
    Q.push(s);
    vis[s] = 1;
    d[s] = 0;
    while(!Q.empty()) {
      int x = Q.front(); Q.pop();
      for(int i = 0; i < G[x].size(); i++) {
        Edge& e = edges[G[x][i]];
        if(!vis[e.to] && e.cap > e.flow) {
          vis[e.to] = 1;
          d[e.to] = d[x] + 1;
          Q.push(e.to);
        }
      }
    }
    return vis[t];
  }

  int DFS(int x, int a) {
    if(x == t || a == 0) return a;
    int flow = 0, f;
    for(int& i = cur[x]; i < G[x].size(); i++) {
      Edge& e = edges[G[x][i]];
      if(d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap-e.flow))) > 0) {
        e.flow += f;
        edges[G[x][i]^1].flow -= f;
        flow += f;
        a -= f;
        if(a == 0) break;
      }
    }
    return flow;
  }

  int Maxflow(int s, int t) {
    this->s = s; this->t = t;
    int flow = 0;
    while(BFS()) {
      memset(cur, 0, sizeof(cur));
      flow += DFS(s, INF);
    }
    return flow;
  }
  int checkExist(){
    for (int i = 0; i < G[0].size(); ++i) {
      Edge& e = edges[G[0][i]];
      if(e.flow!=e.cap)return 0;
    }
    for (int i = 0; i < G[n+1].size(); ++i) {
      Edge& e = edges[G[0][i]];
      if(e.flow!=e.cap)return 0;
    }
    return 1;
  }
};
Dinic g;

int main(){
  int n,m,s,t;
  //cin >> n >> m >> s >>t;
  cin >> n >> m;
  for (int i = 0; i < m; ++i) {
    int u,v,a,b;
    cin >> u >> v >> a >> b;
    g.AddEdge(u, v, b-a,a);
    if(a > 0){
      g.AddEdge(u, n+1, a,0);
      g.AddEdge(0, v, a,0);
    }
  }
  g.Maxflow(0,n+1);
  if(g.checkExist()){
    puts("YES");
    for (int i = 0; i < g.edges.size(); ++i) {
      if(i % 2 || g.edges[i].from==0 || g.edges[i].to==n+1)continue;
      cout << g.edges[i].flow+g.edges[i].lb << endl;
    }
  }
  else{
    puts("NO");
 }
  }
}

Loj #116 有源汇有上下界最大流

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

const int maxn = 200 + 20;
const int INF = 1000000000;

struct Edge {
  int from, to, cap, flow;
};

bool operator < (const Edge& a, const Edge& b) {
  return a.from < b.from || (a.from == b.from && a.to < b.to);
}

struct Dinic {
  int n, m, s, t, removed=0;
  vector<Edge> edges;    // 边数的两倍
  vector<int> G[maxn];   // 邻接表，G[i][j]表示结点i的第j条边在e数组中的序号
  bool vis[maxn];         // BFS使用
  int d[maxn];           // 从起点到i的距离
  int cur[maxn];        // 当前弧指针

  void ClearAll(int n) {
    for(int i = 0; i < n; i++) G[i].clear();
    edges.clear();
  }

  void ClearFlow() {
    for(int i = 0; i < edges.size(); i++) edges[i].flow = 0;
  }

  void AddEdge(int from, int to, int cap) {
    edges.push_back((Edge){from, to, cap, 0});
    edges.push_back((Edge){to, from, 0, 0});
    m = edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
  }

  bool BFS() {
    memset(vis, 0, sizeof(vis));
    queue<int> Q;
    Q.push(s);
    vis[s] = 1;
    d[s] = 0;
    while(!Q.empty()) {
      int x = Q.front(); Q.pop();
      for(int i = 0; i < G[x].size(); i++) {
        Edge& e = edges[G[x][i]];
        if(removed==1 && (e.from==n+1 || e.from==0 || e.to==0 || e.to==n+1))continue;
        if(removed==1 && (G[x][i]==m-1 || G[x][i]==m-2))continue;
        if(!vis[e.to] && e.cap > e.flow) {
          vis[e.to] = 1;
          d[e.to] = d[x] + 1;
          Q.push(e.to);
        }
      }
    }
    return vis[t];
  }

  int DFS(int x, int a) {
    if(x == t || a == 0) return a;
    int flow = 0, f;
    for(int& i = cur[x]; i < G[x].size(); i++) {
      Edge& e = edges[G[x][i]];
      if(removed==1 && (e.from==n+1 || e.from==0 || e.to==0 || e.to==n+1))continue;
      if(removed==1 && (G[x][i]==m-1 || G[x][i]==m-2))continue;
      if(d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap-e.flow))) > 0) {
        e.flow += f;
        edges[G[x][i]^1].flow -= f;
        flow += f;
        a -= f;
        if(a == 0) break;
      }
    }
    return flow;
  }

  int Maxflow(int s, int t) {
    this->s = s; this->t = t;
    int flow = 0;
    while(BFS()) {
      memset(cur, 0, sizeof(cur));
      flow += DFS(s, INF);
    }
    return flow;
  }
  int checkExist(){
    for (int i = 0; i < G[0].size(); ++i) {
      Edge& e = edges[G[0][i]];
      if(e.flow!=e.cap)return 0;
    }
    for (int i = 0; i < G[n+1].size(); ++i) {
      Edge& e = edges[G[0][i]];
      if(e.flow!=e.cap)return 0;
    }
    return 1;
  }
};
Dinic g;

int main(){
  int n,m,s,t;
  cin >> n >> m >> s >>t;
  g.n=n;
  for (int i = 0; i < m; ++i) {
    int u,v,a,b;
    cin >> u >> v >> a >> b;
    g.AddEdge(u, v, b-a);
    if(a > 0){
      g.AddEdge(u, n+1, a);
      g.AddEdge(0, v, a);
    }
  }
  g.AddEdge(t, s, INF);
  g.Maxflow(0,n+1);
  //cout << " max flow " << endl;
  if(g.checkExist()){
    int ans=g.edges[g.m-2].flow;
    g.removed=1;
    //cout << " max flow " << endl;
    ans += g.Maxflow(s,t);
    //cout << " max flow " << endl;
    cout << ans << endl;
  }
  else{
    puts("please go home to sleep");
  }
}

Loj #117 有源汇有上下界最小流

#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
const int maxn = 50000 + 20;
const int INF = 1000000000;

struct Edge {
  int from, to;
  ll cap, flow;
};

bool operator < (const Edge& a, const Edge& b) {
  return a.from < b.from || (a.from == b.from && a.to < b.to);
}

struct Dinic {
  int n, m, s, t, removed=0;
  vector<Edge> edges;    // 边数的两倍
  vector<int> G[maxn];   // 邻接表，G[i][j]表示结点i的第j条边在e数组中的序号
  bool vis[maxn];         // BFS使用
  int d[maxn];           // 从起点到i的距离
  int cur[maxn];        // 当前弧指针

  void ClearAll(int n) {
    for(int i = 0; i < n; i++) G[i].clear();
    edges.clear();
  }

  void ClearFlow() {
    for(int i = 0; i < edges.size(); i++) edges[i].flow = 0;
  }

  void AddEdge(int from, int to, ll cap) {
    edges.push_back((Edge){from, to, cap, 0});
    edges.push_back((Edge){to, from, 0, 0});
    m = edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
  }

  bool BFS() {
    memset(vis, 0, sizeof(vis));
    queue<int> Q;
    Q.push(s);
    vis[s] = 1;
    d[s] = 0;
    while(!Q.empty()) {
      int x = Q.front(); Q.pop();
      for(int i = 0; i < G[x].size(); i++) {
        Edge& e = edges[G[x][i]];
        if(removed==1 && (e.from==n+1 || e.from==0 || e.to==0 || e.to==n+1))continue;
        if(removed==1 && (G[x][i]==m-1 || G[x][i]==m-2))continue;
        if(!vis[e.to] && e.cap > e.flow) {
          vis[e.to] = 1;
          d[e.to] = d[x] + 1;
          Q.push(e.to);
        }
      }
    }
    return vis[t];
  }

  ll DFS(int x, ll a) {
    if(x == t || a == 0) return a;
    int flow = 0, f;
    for(int& i = cur[x]; i < G[x].size(); i++) {
      Edge& e = edges[G[x][i]];
      if(removed==1 && (e.from==n+1 || e.from==0 || e.to==0 || e.to==n+1))continue;
      if(removed==1 && (G[x][i]==m-1 || G[x][i]==m-2))continue;
      if(d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap-e.flow))) > 0) {
        e.flow += f;
        edges[G[x][i]^1].flow -= f;
        flow += f;
        a -= f;
        if(a == 0) break;
      }
    }
    return flow;
  }

  ll Maxflow(int s, int t) {
    this->s = s; this->t = t;
    ll flow = 0;
    while(BFS()) {
      memset(cur, 0, sizeof(cur));
      flow += DFS(s, INF);
    }
    return flow;
  }
  int checkExist(){
    for (int i = 0; i < G[0].size(); ++i) {
      Edge& e = edges[G[0][i]];
      if(e.flow!=e.cap)return 0;
    }
    for (int i = 0; i < G[n+1].size(); ++i) {
      Edge& e = edges[G[0][i]];
      if(e.flow!=e.cap)return 0;
    }
    return 1;
  }
};
Dinic g;

int main(){
  int n,m,s,t;
  cin >> n >> m >> s >>t;
  g.n=n;
  for (int i = 0; i < m; ++i) {
    int u,v,a,b;
    cin >> u >> v >> a >> b;
    g.AddEdge(u, v, b-a);
    if(a > 0){
      g.AddEdge(u, n+1, a);
      g.AddEdge(0, v, a);
    }
  }
  g.AddEdge(t, s, INF);
  g.Maxflow(0,n+1);
  //cout << " max flow " << endl;
  if(g.checkExist()){
    ll ans=g.edges[g.m-2].flow;
    g.removed=1;
    //cout << " max flow " << endl;
    ans -= g.Maxflow(t,s);
    //cout << " max flow " << endl;
    cout << ans << endl;
  }
  else{
    puts("please go home to sleep");
  }
}
WorstCoder
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
可行流
ACM之梦
11-13 2655
对于无源汇问题,方法有两种. 1 从边的角度来处理. 新建超级源汇, 对于每一条有下界的边,x->y, 建立有向边 超级源->y ,容量为x->y下界,建立有向边 x-> 超级汇,容量为x->y下界.建立有向边 x->y,容量为x->y的上界减下界. 2 从点的角度来处理. 新建超级源汇,对于每个点流进的下界和为 in, 流出此点的下界和为out.如果in > out. 建立有
流量有上下界的网络的最大流和最小流算法
始往流离，终彼成章。
02-19 7362
/************************************************************ 算法引入： 基础的网络流的每一条弧都对应一个弧容量c(u,v)>=0; 而有上下界的网络流中，每条弧对应两个权值b(u,v)和c(u,v),即为弧流量的下界和上界； 很显然基础的网络流中为其特殊情况，即b(u,v)==0的时候; 算法分析： (1)最大流： 当b(u,v
[网络流]学习笔记：一次理解网络流！
热门推荐
A_Comme_Amour的博客
02-23 2万+
学一个新算法，总要翻多而杂的blog，收获不多。所以我就致力于把学习笔记总结，希望一遍看懂。 简单入门 （但是不全） 一、从概念入手 网络流用于解决流量问题 网络流:所有弧上流量的集合f={f(u,v)},称为该容量网络的一个网络流. 定义：带权的有向图G=(V,E)，满足以下条件，则称为网络流图(flow network)： 仅有一个入度为0的顶点s，称s为源点 仅有一个出...
网络流
weixin_42638946的博客
09-27 1220
网络流 1. 网络流原理 原理 1.1 流网络 是一个有向图G=(V, E)，可以存在环。该有向图中存在一个源点s和一个汇点t。边上的权重被称为容量c。 如下图就是一个流网络： 1.2 可行流 可行流f表示满足一定条件的网络流。需要满足如下两个条件： （1）容量限制：0≤f(u,v)≤c(u,v)0 \le f(u, v) \le c(u, v)0≤f(u,v)≤c(u,v)，其中 f(u,v)、c(u,v)f(u, v)、c(u, v)f(u,v)、c(u,v) 分别表示从u到v
最大流/最小割
fenggaoyuehei的专栏
11-25 5370
图论中的一种理论与方法，研究网络上的一类最优化问题 。1955年 ，T.E. 哈里斯在研究铁路最大通量时首先提出在一个给定的网络上寻求两点间最大运输量的问题。1956年，L.R. 福特和 D.R. 富尔克森等人给出了解决这类问题的算法，从而建立了网络流理论。所谓网络或容量网络指的是一个连通的赋权有向图 D＝ （V、E、C） ， 其中V 是该图的顶点集，E是有向边(即弧)集，C是弧上的容量。此外顶点集中包括一个起点和一个终点。网络上的流就是由起点流向终点的可行流，这是定义在网络上的非负函数，它一方面受到容量的
有源汇的上下界可行流
04-24
【有源汇的上下界可行流】是指在网络流问题中，网络图的每个弧（边）都有一个容量上限和下限，且存在一个特殊的节点称为源（source）和一个称为汇（sink）的节点。这样的网络流问题可以分为两类：有源汇网络和无源汇...
最大流_最大流模板_
09-30
最大流问题描述如下：给定一个有向加权图G，其中每条边有一个容量限制，并且有两个特殊的节点——源点s和汇点t。源点向其他节点发送流量，而汇点接收流量。我们的目标是确定从源点到汇点的最大可能流量，同时满足每...
最大流和最小截.zip
05-14
最大流和最小截是图论中的两个重要概念，它们在计算机科学、网络优化以及运筹学等领域有着广泛的应用。在本资料中，我们主要探讨如何使用MATLAB语言来实现这两种算法。 最大流问题旨在寻找一个网络（有向图）中从源...
上下界网络流
04-16
"上下界网络流" 上下界网络流是一种特殊的网络流，边的流量有限制，必须在[down, up]的范围内。...5. 当且仅当附加弧都满流时是有可行流，最后的最小流是 flow[sd->st]^1], st 到 sd 的最大流就是 sd 到 st 的最小流。
zuidaliu.rar_matlab最大流_最大流 MATLAB
最新发布
09-21
这个流量是所有可行流中的最大值，同时满足两个关键条件：流量守恒和容量约束。流量守恒意味着每个中间节点的流入流量等于流出流量；容量约束则规定每条边的流量不能超过其自身的容量。 MATLAB中的最大流算法通常...
网络流之最大流
weixin_52551400的博客
03-20 260
网络流的基本概念 在一张有向图中 G = (V, E) 中有一个源点 S 和一个汇点 T。 源点 S 有无限多的水流可以向外流出，汇点 T 可以接受无限多的水流。 其中对于每一条有向边有一个边权代表这条有向边最大可以流过的流量(用 c(u, v) 来表示)。 最大流指的是最大可行流 残留网络 然后每一个流都会有一个残留网络 残留网络指的是在原网络中指定了可行流之后对应的一个网络流，原网络的一个可行流对应一个残留网络。 该红色箭头的所指路径即为残留网络 其中的 其中残留网络的可行流 f’ 同样需满足 流量守
【模板】最大流之上下界可行流
Fighting_Peter的博客
01-23 386
ACM模板 目录无源汇上下界可行流有源汇上下界最大流有源汇上下界最小流 无源汇上下界可行流 问题： 给定一个网络，求一个流满足：每条边的流量处在给定的下界和上届[lower,upper]之间，满足流量守恒 首先我们在原网络中确定一个全部是下界的流网络，当然此流不一定是可行流因为其不一定满足流量守恒，不妨叫此流流① 此时问题转化成找到一个流②，每条边的流量处在[0,upper-lower]之间，此流与之前的流①相加（流①+流②）满足流量守恒，是一个可行流。显然流②不一定是可行流，但是我们可以经过以下调整
无源汇有上下界可行流（网络流进阶）
weixin_30349597的博客
06-16 361
无源汇有上下界可行流(也就是循环流) 模型:一个网络,求出一个流,使得每条边的流量必须>=Li且<=Hi, 每个点必须满足总流入量=总流出量(流量守恒)(这个流的特点是循环往复,无始无终) 可行流算法的核心是将一个不满足流量守恒的初始流调整成满足流量守恒的流 流量守恒,即每个点的总流入量=总流出量 如果存在一个可行流,那么一定满足每条边的流量...
一句话网络流（EK，Dinic，最小费最大流，（最大/最小）可行流，最小费用可行流）
积极的防守者的博客
05-09 1861
EK算法求最大流： BFS找增广路增广直到无法增广 复杂度：O(V*E^2) 核心代码（邻接表存图）：（一开始学最大流的时候写的代码，非常丑） int pre[maxn]; int vis[maxn]={0}; bool bfs(){//bfs求路径 for(int i = 0;i <= n+1;++i) vis[i] = 0; queue<int> q;q.push(0);...
有源汇有上下界可行流/最大流
babing2770的博客
06-18 255
解析为转载 ：https://www.cnblogs.com/liu-runda/p/6262832.html 博主讲的挺好的 有源汇有上下界可行流 模型:现在的网络有一个源点s和汇点t,求出一个流使得源点的总流出量等于汇点的总流入量,其他的点满足流量守恒,而且每条边的流量满足上界和下界限制. 源点和汇点不满足流量守恒,这让我们很难办,因此我们想办法把问题转化成容易处理的每个点...
poj 2396(有上下界的 可行流)
Weiguang_123的专栏
08-05 830
Amber大牛的《图论原理》： 问题模型： 给定一个加权的有向图，满足： (1)容量限制条件： (2)流量平衡条件： (2)中的即除了源汇外，所有点都满足流量平衡条件，则称G为有源汇网络；否则，即不存在源汇，所有点都满足流量平衡条件，则称G为无源汇网络。 将这类问题由易到难一一解决： 问题[1] 求无源汇的网络有上下界的可行流 由于下界是一条弧上的流必需要满
POJ ~ 2396 ~ Budget （有源汇上下界可行流）
张松超的博客
09-12 239
题意 T组测试数据，给你一个n*m的矩阵，输入每一行的和，每一列的和，在输入一些形如x y &gt; z限制条件，如果x为0表示所有行，y为0表示所有列，x==0，y==0表示整个矩阵。求是否村子满足要求的矩阵，存在就输出矩阵。   思路 转化为有源汇上下界可行流来做。 行列看作点，行为Xi，列为Yi，建立源点s，汇点t。 ①源点向行Xi建边，上下界均为行和 ②列Yi向汇点Yi建边，...
bzoj1927: [Sdoi2010]星际竞速
weixin_30652491的博客
07-11 114
跟上一题几乎一样。。。 #include<cstdio> #include<cstring> #include<iostream> #include<algorithm> #include<queue> using namespace std; #define rep(i,n) for(int i=1;i<=n;i...
网络流模板（费用流/可行流/上下界）
zawedx的博客
04-07 1927
终于来写博客了= = 一般的最大流 算法：dinic          博主只会这个 大概就是先bfs分层，在增广的时候只走跨层边 加当前弧优化好像快10倍左右，加的时候小心点，容易错 应该只有我会写成暴力吧 struct edge{int t,f,n;}E[M]; void add(int x,int y,int f){ E[++tot]=(edge){y,f,ft
最大流Dinic算法详解：构建无源汇上下界可行流
"本文主要介绍了无源汇有上下界可行流的概念，以及如何利用Dinic算法求解最大流的问题。该算法基于链式前向星数据结构，通过BFS分层和DFS寻找增广路逐步增加网络的流量，直至无法找到增广路为止。" 在图论和计算机...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值