网络流(四) 最大流判断，分层图，拆点

最新推荐文章于 2024-03-15 23:25:02 发布
最新推荐文章于 2024-03-15 23:25:02 发布
阅读量493 收藏 1
点赞数
分类专栏： 图 文章标签： 图论 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cjx2774952383/article/details/126797696
版权

网络流(四) 最大流判断，分层图，拆点

最大流判断：秘密挤奶机

经典最大值最小问题，可以直接二分出最大的边权mid，看是否存在一个最大流，其中所有边权都小于等于mid，且流量大于K，不断二分下去即可找到答案。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#define int long long
using namespace std;
const int N = 210, M = 80010, inf = 1e18;
int n, m, S, T, K;
int h[N], e[M], f[M], ne[M], w[M], idx;
int q[N], d[N], cur[N];
void add(int a, int b, int c){
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
    e[idx] = a, w[idx] = c, ne[idx] = h[b], h[b] = idx ++;
}
bool bfs(){
    int hh = 0, tt = 0;
    memset(d, -1, sizeof(d));
    q[0] = S;
    d[S] = 0;
    cur[S] = h[S];
    while(hh <= tt){
        int t = q[hh ++];
        for(int i = h[t]; i != -1; i = ne[i]){
            int ver = e[i];
            if(d[ver] == -1 && f[i]){
                d[ver] = d[t] + 1;
                cur[ver] = h[ver];
                if(ver == T){
                    return true;
                }
                q[++ tt] = ver;
            }
        }
    }
    return false;
}
int find(int u, int limit){
    if(u == T){
        return limit;
    }
    int flow = 0;
    for(int i = cur[u] ; i != -1 && flow < limit; i = ne[i]){
        cur[u] = i;
        int ver = e[i];
        if(d[ver] == d[u] + 1 && f[i]){
            int t = find(ver, min(f[i], limit - flow));
            if(!t){
                d[ver] = -1;
            }
            f[i] -= t;
            f[i ^ 1] += t;
            flow += t;
        }
        
    }
    return flow;
}
int dinic(){
    int r = 0, flow;
    while(bfs()){
        while(flow = find(S, inf)){
            r += flow;
        }
    }
    return r;
}
bool check(int mid){
    for(int i = 0; i < idx; i ++){
        if(w[i] > mid){
            f[i] = 0;
        }
        else{
            f[i] = 1;
        }
    }
    return dinic() >= K;
}
signed main(){
    scanf("%lld%lld%lld",&n, &m, &K);
    S = 1;
    T = n;
    memset(h, -1, sizeof(h));
    while(m --){
        int a, b, c;
        scanf("%lld%lld%lld",&a, &b, &c);
        add(a, b, c);
    }
    int l = 0, r = 1e9;
    while(l < r){
        int mid = (l + r) >> 1;
        if(check(mid)){
            r = mid;
        }
        else{
            l = mid + 1;
        }
    }
    printf("%lld\n", r);
}

分层图：星际转移问题

当网络流问题中引入了距离概念时，我们可以考虑分层图。我们可以把分出k层图，第 i i i 层表示第 i i i天，源点向每一个“地球”连一条容量为无穷大的边，每个空间站向下一时间的该空间站连一条容量为去穷大的边，代表时间间的转移。

参考代码：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1101 * 50 + 10, M = (N + 1100 + 20 * 1101) + 10, INF = 1e8;

int n, m, k, S, T;
int h[N], e[M], f[M], ne[M], idx;
int q[N], d[N], cur[N];
struct Ship
{
    int h, r, id[30];
}ships[30];
int p[30];

int find(int x)
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int get(int i, int day)
{
    return day * (n + 2) + i;
}

void add(int a, int b, int c)
{
    e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
    e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx ++ ;
}

bool bfs()
{
    int hh = 0, tt = 0;
    memset(d, -1, sizeof d);
    q[0] = S, d[S] = 0, cur[S] = h[S];
    while (hh <= tt)
    {
        int t = q[hh ++ ];
        for (int i = h[t]; ~i; i = ne[i])
        {
            int ver = e[i];
            if (d[ver] == -1 && f[i])
            {
                d[ver] = d[t] + 1;
                cur[ver] = h[ver];
                if (ver == T) return true;
                q[ ++ tt] = ver;
            }
        }
    }
    return false;
}

int find(int u, int limit)
{
    if (u == T) return limit;
    int flow = 0;
    for (int i = cur[u]; ~i && flow < limit; i = ne[i])
    {
        cur[u] = i;
        int ver = e[i];
        if (d[ver] == d[u] + 1 && f[i])
        {
            int t = find(ver, min(f[i], limit - flow));
            if (!t) d[ver] = -1;
            f[i] -= t, f[i ^ 1] += t, flow += t;
        }
    }
    return flow;
}

int dinic()
{
    int r = 0, flow;
    while (bfs()) while (flow = find(S, INF)) r += flow;
    return r;
}

int main()
{
    scanf("%d%d%d", &n, &m, &k);
    S = N - 2, T = N - 1;
    memset(h, -1, sizeof h);
    for (int i = 0; i < 30; i ++ ) p[i] = i;
    for (int i = 0; i < m; i ++ )
    {
        int a, b;
        scanf("%d%d", &a, &b);
        ships[i] = {a, b};
        for (int j = 0; j < b; j ++ )
        {
            int id;
            scanf("%d", &id);
            if (id == -1) id = n + 1;
            ships[i].id[j] = id;
            if (j)
            {
                int x = ships[i].id[j - 1];
                p[find(x)] = find(id);
            }
        }
    }
    if (find(0) != find(n + 1)) puts("0");
    else
    {
        add(S, get(0, 0), k);
        add(get(n + 1, 0), T, INF);
        int day = 1, res = 0;
        while (true)
        {
            add(get(n + 1, day), T, INF);
            for (int i = 0; i <= n + 1; i ++ )
                add(get(i, day - 1), get(i, day), INF);
            for (int i = 0; i < m; i ++ )
            {
                int r = ships[i].r;
                int a = ships[i].id[(day - 1) % r], b = ships[i].id[day % r];
                add(get(a, day - 1), get(b, day), ships[i].h);
            }
            res += dinic();
            if (res >= k) break;
            day ++ ;
        }

        printf("%d\n", day);
    }

    return 0;
}

拆点：餐饮

当点的使用次数有限制时，可以把该点拆成一个入点， 一个出点，在入点到处点之间连一条边，容量为该点的使用次数。

建图大致如下：

在这里插入图片描述

参考代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#define int long long
using namespace std;
const int N = 1e3 + 10, M = 1e5 + 10, inf = 1e18;
int n, F, D, S, T;
int h[N], e[M], f[M], ne[M], idx;
int q[N], d[N], cur[N];

void add(int a, int b, int c){
    e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx ++;
    e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx ++;
}

bool bfs(){
    int hh = 0, tt = 0;
    memset(d, -1, sizeof(d));
    q[0] = S;
    d[S] = 0;
    cur[S] = h[S];
    while(hh <= tt){
        int t = q[hh ++];
        for(int i = h[t]; i != -1; i = ne[i]){
            int ver = e[i];
            if(d[ver] == -1 && f[i]){
                cur[ver] = h[ver];
                d[ver] = d[t] + 1;
                if(ver == T){
                    return true;
                }
                q[++ tt] = ver;
            }
        }
    }
    return false;
}

int find(int u, int limit){
    if(u == T){
        return limit;
    }
    int flow = 0;
    for(int i = cur[u]; i != -1 && flow < limit; i = ne[i]){
        cur[u] = i;
        int ver = e[i];
        if(d[ver] == d[u] + 1 && f[i]){
            int t = find(ver, min(limit - flow, f[i]));
            if(!t){
                d[ver] = -1;
            }
            f[i] -= t;
            f[i ^ 1] += t;
            flow += t;
        }
    }
    return flow;
}
int dinic(){
    int r = 0, flow;
    while(bfs()){
        while(flow = find(S, inf)){
            r += flow;
        }
    }
    return r;
}
signed main(){
    scanf("%lld%lld%lld",&n, &F, &D);
    S = 0;
    T = 2 * n + F + D;
    memset(h, -1, sizeof(h));
    for(int i = 2 * n + 1; i <= 2 * n + F; i ++){
        add(S, i, 1);
    }
    for(int i = 2 * n + F + 1; i <= 2 * n + F + D; i ++){
        add(i, T, 1);
    }
    for(int i = 1; i <= n ; i ++){
        add(i, n + i, 1);
        int a, b, t;
        scanf("%lld%lld",&a, &b);
        while(a --){
            scanf("%lld", &t);
            add(n * 2 + t, i , 1);
        }
        while(b --){
            scanf("%lld", &t);
            add(i + n, n * 2 + F + t, 1);
        }
    }
    printf("%lld\n", dinic());
}

拆点：最长不下降子序列问题

由题意得：第一问直接二维dp求最长不下降子序列长度即可。第二问，每个点只能受用一次，问最长不下降子序列有多少个，首先每个点只能使用一次，即对点数有限制，我们对每个点进行拆点。用 f [ i ] f[i] f[i] 表示 以第 i i i 个数结尾，最长不下降子序列的长度，当 j < i j < i j<i a [ j ] < = a [ i ] a[j] <= a[i] a[j]<=a[i] 并且 $f[j] == f[i] - 1 $ 则从 j j j 连一条边到 i i i ， 从源点S 向所有 f [ i ] = 1 f[i] = 1 f[i]=1的点连一条边权为1边， 从所有 f [ i ] = = m a x l e n f[i] == maxlen f[i]==maxlen 的点连一条边到汇点t， 再从每个入点连一条边权为1的边到出点。第三问只需要将第二问中的，限制改为无限制(边权为无穷大)即可。

参考代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#define int long long
using namespace std;
const int N = 1010, M = 3e5+10, inf = 1e18;
int n, S, T;
int h[N], e[M], ne[M], f[M], idx;
int a[N], F[N];
int d[N], q[N], cur[N];
void add(int a, int b, int c){
    e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx ++;
    e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx ++;
}
bool bfs(){
    int hh = 0, tt = 0;
    memset(d, -1, sizeof(d));
    q[0] = S;
    d[S] = 0;
    cur[S] = h[S];
    while(hh <= tt){
        int t = q[hh ++];
        for(int i = h[t]; i != -1; i = ne[i]){
            int ver = e[i];
            if(d[ver] == -1 && f[i]){
                d[ver] = d[t] + 1;
                cur[ver] = h[ver];
                if(ver == T){
                    return true;
                }
                q[++ tt] = ver;
            }
        }
    }
    return false;
}
int find(int u, int limit){
    if(u == T){
        return limit;
    }
    int flow = 0;
    for(int i = cur[u]; i != -1 && flow < limit; i = ne[i]){
        cur[u] = i;
        int ver = e[i];
        if(d[ver] == d[u] + 1 && f[i]){
            int t = find(ver, min(limit - flow, f[i]));
            if(!t){
                d[ver] = -1;
            }
            f[i] -= t;
            f[i ^ 1] += t;
            flow += t;
        }
    }
    return flow;
}
int dinic(){
    int r = 0, flow;
    while(bfs()){
        while(flow = find(S, inf)){
            r += flow;
        }
    }
    return r;
}
signed main(){
    scanf("%lld",&n);
    memset(h, -1, sizeof(h));
    for(int i = 1; i <= n ;i ++){
        scanf("%lld",&a[i]);
    } 
    S = 0;
    T = 2 * n + 1;
    int s = 0;
    for(int i = 1; i <= n ; i ++){
        add(i, n + i, 1);
        F[i] = 1;
        for(int j = 1; j < i ; j ++){
            if(a[j] <= a[i]){
                F[i] = max(F[i], F[j] + 1);
            }
        }
        for(int j = 1; j < i ; j ++){
            if(a[j] <= a[i] && F[j] + 1 == F[i]){
                add( n+j, i, 1);
            }
        }
        s = max(s, F[i]);
        if(F[i] == 1){
            add(S, i, 1);
        }
    }
    for(int i = 1; i <= n ; i ++){
        if(F[i] == s){
            add(n + i, T, 1);
        }
    }
    printf("%lld\n", s);
    if(s == 1){
        printf("%lld\n%lld\n", n, n);
    }
    else{
        int res = dinic();
        printf("%lld\n", res);
        for(int i = 0; i < idx ; i += 2){
            int a = e[i ^ 1];
            int b = e[i];
            if(a == S && b == 1){
                f[i] = inf;
            }
            else if(a == 1 && b == n + 1){
                f[i] = inf;
            }
            else if(a == n && b == 2 * n){
                f[i] = inf;
            }
            else if(a == 2 * n && b == T){
                f[i] = inf;
            }
        }
        printf("%lld\n", res + dinic());
    }
}

蜥蜴

由题意得：蜥蜴从起始柱子跳出边界时就算逃脱，直接从所有到边界距离小于等于D的柱子的出点向汇点连一条边权为无穷大的点(因为当能够流到柱子的出点时表示能够作为起跳点)。从每个柱子的入点向出点连一条边权为该柱子起始高度的边，从源点向所有初始时刻有蜥蜴的柱子连一条边权为蜥蜴个数边。

参考代码：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <map>
#define int long long
using namespace std;
typedef pair<int, int> PII;
const int N = 1e3 + 10, M = 2e5 + 10, inf = 1e18;
const double eps = 1e-8;
int h[N], e[M], ne[M], f[M], idx;
int q[N], d[N], cur[N];
int n, m, S, T, cnt_n, cnt_m;
PII zhuzi[M];
double D;
map<PII, int> pp;
string xiyi1[N], high1[N];
double check(PII a, PII b)
{
    double dx = a.first - b.first;
    double dy = a.second - b.second;
    return dx * dx + dy * dy < D * D + eps;
}
void add(int a, int b, int c)
{
    e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx++;
    e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx++;
}
bool bfs()
{
    int hh = 0, tt = 0;
    memset(d, -1, sizeof(d));
    q[0] = S;
    d[S] = 0;
    cur[S] = h[S];
    while (hh <= tt)
    {
        int t = q[hh++];
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int ver = e[i];
            if (d[ver] == -1 && f[i])
            {
                d[ver] = d[t] + 1;
                cur[ver] = h[ver];
                if (ver == T)
                {
                    return true;
                }
                q[++tt] = ver;
            }
        }
    }
    return false;
}
int find(int u, int limit)
{
    if (u == T)
    {
        return limit;
    }
    int flow = 0;
    for (int i = cur[u]; i != -1 && flow < limit; i = ne[i])
    {
        cur[u] = i;
        int ver = e[i];
        if (d[ver] == d[u] + 1 && f[i])
        {
            int t = find(ver, min(limit - flow, f[i]));
            if (!t)
            {
                d[ver] = -1;
            }
            f[i] -= t;
            f[i ^ 1] += t;
            flow += t;
        }
    }
    return flow;
}
int dinic()
{
    int r = 0, flow;
    while (bfs())
    {
        while (flow = find(S, inf))
        {
            r += flow;
        }
    }
    return r;
}

signed main()
{
    cin >> n >> m >> D;
    memset(h, -1, sizeof(h));
    for (int i = 1; i <= n; i++)
    {
        cin >> high1[i];
        high1[i] = " " + high1[i];
    }
    for (int i = 1; i <= n; i++)
    {
        cin >> xiyi1[i];
        xiyi1[i] = " " + xiyi1[i];
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            if (high1[i][j] >= '1' && high1[i][j] <= '9')
            {
                zhuzi[++cnt_n] = {i, j};
                pp[{i, j}] = cnt_n;
            }
        }
    }
    S = 0;
    T = cnt_n * 2 + 1;
    for(int i = 1; i <= cnt_n; i ++){
        if(zhuzi[i].first <= D || zhuzi[i].first + D > n || zhuzi[i].second <= D || zhuzi[i].second + D > m){
            add(i + cnt_n, T, inf);
        }
        add(i, i + cnt_n, (high1[zhuzi[i].first][zhuzi[i].second] - '0'));
    }
    int sum = 0;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            if (xiyi1[i][j] == 'L')
            {
                sum ++;
                add(S, pp[{i, j}], 1);
            }
        }
    }
    for(int i = 1; i <= cnt_n; i ++){
        for(int j = 1; j <= cnt_n; j ++){
            if(i == j){
                continue;
            }
            if(check(zhuzi[i], zhuzi[j])){
                add(i + cnt_n, j, inf);
            }
        }
    }
    int ans = dinic();
    //printf("%lld\n", dinic());
    printf("%lld\n", sum - ans);
    /*
    for(int i = 1; i <= n ; i ++){
        cout << high1[i] << endl;
    }
    for(int i = 1; i <= n ; i ++){
        cout << xiyi1[i] << endl;
    }
    */
}
塵稼轩
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分层法求解网络最大流的研究
03-28
分层法首先构造原有向网络对应的层次网络,接着在构造出的层次网络中计算各相邻结点层之间的最大流,以此为基础最终获得整个网络最大流的快速估算.分层法有效降低了计算的复杂性,为在大规模网络中快速获取最大流的求解...
最大流之Dinic算法
mmmmmk_的博客
04-09 648
Dinic是一个分层的增广路算法。Dinic中分层的概念定义为：到原结点的最小距离相同的点为同一层。 假设有拓扑如下：如果源点为1，宿点为4；拓扑可以分成4层。 首先，回想E-K算法是怎么算的：使用DFS在1到4之间计算一条增广路，并计算残量网络；再进行循环。我们观察计算第一次增广路（1->2->3->4）之后的残量网络，橙色的表示反向弧。 从图中可以看出，其实这个时候1->2->5->4
网络流常用小技巧之 拆点
harry12138小白的博客
01-29 776
一、什么是拆点 拆点就是将一个点拆成入点和出点两个点，并在两个点之间建一条边。 二、为什么要拆点 拆点是为了实现对点的限制。 三、什么时候需要拆点 如第二点，当题目中明确说明对点有限制或在实际应用中对点有限制时，我们就需要拆点。例如我们要保证经过某点中转的流量不能大于5（对点有流量限制），那么我们就需要将该点拆成入点和出点，并在两点间建一条容量为5的边，就实现了对点的限制。 四、总结 做题时一定要看清，如果是对边有限制，就通过流量或流网络来实现；如果是对点有限制，就通过拆点来实现。 五、例题分析 acwin
图论学习-网络流之最大流初步
麒麟001号的博客
03-30 299
文章目录一、基本概念1.1 术语1.2 原理1.3 最大流最小割定理二、算法模板2.1 EK O(n * m^2)2.1.1 代码实现2.2 dinic O(m * n^2)2.2.1 原理2.2.2 小注2.2.3 实现步骤2.2.4 需要注意的地方2.2.3 代码实现三、应用四、拓展 图论学习-网络流初步 一、基本概念 1.1 术语 1.2 原理 1.3 最大流最小割定理 基本内容： 对于流网络G，有一个可行流f： 那么对于该可行流的残留网络Gf,如果不存在增广路，则f是一个最大流 二、算法模板 2.1
对网络流的一个小总结
qq_61305213的博客
08-30 130
网络流 与二分图的小总结
网络流——最大流（全）
李响
11-03 5278
1、最大流 2、最小费用最大流 先从最基础的最大流开始： 何为最大流问题？ 简单来说就是水流从一个源点s通过很多路径，经过很多点，到达汇点t，问你最多能有多少水能够到达t点。 从s到t经过若干个点，若干条边，每一条边的水流都不能超过边权值（可以小于等于但不能大于），所以该图的最大流就是10+22+45=77。 如果你还是不能理解，我们就换一种说法，假设s城有inf个人想去t城，但是从s到t要...
网络流（三） 最小边割与最小点割
Hello World!
02-16 4117
网络流除了可以求图中的最大流，最小费用流，二分图完美匹配之外，还可以来求图的最小点割/边割集，再加上拆点法和建立源点汇点的使用，使得网络流可以灵活解决其他的建模问题。
网络流从入门到入土_MolotovM.pptx
01-27
网络流是一种在图论中的...从基础的网络流图概念，到最大流的定义和计算，再到各种优化算法，这些知识构成了网络流理论的核心。通过学习和掌握这些概念，我们可以解决许多实际问题，并在实际应用中实现资源的最优配置。
固体颗粒在液固流化床内分层机理的探讨
06-16
在对固体颗粒的沉降速度分层学说和密度分层学说两种理论进行分析的基础上,研究了固体颗粒在液固流化床内的分层机理,并通过窄粒级和宽粒级物料的流化试验,得出了固体颗粒按照自身沉降速度在液固流化床中分层的结论。
论文研究-累计分层P2P流媒体数据分配算法.pdf
07-22
CLSPA），该算法使媒体服务质量指标中的服务启动时间（媒体数据块开始传输与在接收点连续播放该数据块之间的缓冲延迟）得到优化，同时保证动态环境流媒体的播放质量。仿真实验表明，CLSPA与其他算法相比，在服务启动...
瀑布流图片展示站分层模板
05-26
瀑布流图片展示站分层模板是一种常见的网页设计布局方式，尤其适用于图片丰富的网站，如摄影作品展示、电商产品展示等。这种布局模式以其独特的视觉效果和用户体验，深受设计师和开发者们的喜爱。在这个模板中，我们...
最大流判定（星际转移问题）
qq_52093121的博客
11-15 295
一种方式是坐公交车，从一个站点到另一个站点，那么就可以根据每辆公交车的路线来建边，假设某一辆公交车最开始在第 0 个站点，然后依次开往第 2 个站点，再开往第 5 个站点，那么先从第 0 天的第 0 个站点向第 1 天的第 2个站点连一条边，再从第 1 天的第 2 个站点向第 3 天的第 5 个站点连一条边，容量都是这个公交车的人数上限，其他路线依次类推。可以发现可行解中每个人行走的方式都能对应到流网络中的某一条边，只需要根据该方式移动的人数来设置对应的边的流量，就能得到对应的可行流，反过来同理。
网络流建模之拆点，原理详解，OJ练习
最新发布
EQUINOX1的博客
03-15 1166
一种常用的网络流建模方式
最大流（刚开始接触的总结）
flyljg的专栏
08-18 955
刚开始接触最大流问题，也是一头雾水，看了一上午的
最大流问题
涛涛不解
08-25 3110
http://www.cppblog.com/Icyflame/archive/2009/06/23/88364.html 最大流问题  一、    定义与定理 流网络：G=(V, E)是一个有向图，其中每条边(u, v)∈E均有一个非负容量c(u, v) ≤0，否则c(u, v)为0.流网络中有两个特别的顶点：源点s和汇点t。对于每个顶点v∈V，都存在一条路径s…v…t。 流
【网络流】最大流：最大流判定，拆点，建图实战
ZYzyZzzz的博客
08-11 694
最大流判定 秘密挤奶机 原题链接 给出一张包含NNN个点，PPP条边的无向图，1→N1\rightarrow N1→N走TTT次，每条边最多走111次。 问：TTT条路径中最大边权的最小值。 用dinic+dinic+dinic+二分。 判定问题：在无向图中，删除大于midmidmid的边，查找边权≤mid\leq mid≤mid的边，1→N1\rightarrow N1→N是否存在TTT条没有公共边的路径。 建图：将无向图变为有向图： S=1,T=nS=1,T=nS=1,T=n，最大可行流流量===路
最大流（网络流基础概念+三个算法）
热门推荐
x_y_q_的博客
07-22 3万+
下面是由一道题引发的一系列故事。。。 题目链接 http://poj.org/problem?id=1273 Drainage Ditches Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 68920 Accepted: 26683 Descri
网络流（最大流）基础入门
lzoi_hmh的博客
07-11 1万+
好不容易大概搞懂了网络流，写个博客巩固一下 **定义 网络流与最大流**网络流是指给定一个有向图，和两个点–源点S和汇点T，点之间有连边， 每条边有一个容量限制，可以看作水管，网络流就是指由S点流到T点的一个可行流。 最大流就是指所有可行流里面最大的流。通俗的讲，就是由若干个运货点，一个是起点，一个是终点，有一些运货点由路相连，每条路有容量限制，走过那条路时运送的货物不能超过其中的容量限制，求
网络流之最大流
weixin_52551400的博客
03-20 262
网络流的基本概念 在一张有向图中 G = (V, E) 中有一个源点 S 和一个汇点 T。 源点 S 有无限多的水流可以向外流出，汇点 T 可以接受无限多的水流。 其中对于每一条有向边有一个边权代表这条有向边最大可以流过的流量(用 c(u, v) 来表示)。 最大流指的是最大可行流 残留网络 然后每一个流都会有一个残留网络 残留网络指的是在原网络中指定了可行流之后对应的一个网络流，原网络的一个可行流对应一个残留网络。 该红色箭头的所指路径即为残留网络 其中的 其中残留网络的可行流 f’ 同样需满足 流量守
Dinic算法详解：最大流与BFS分层处理
"本文主要介绍了 Dinic 算法，特别是如何通过 BFS 进行分层处理以求解网络流中的最大流问题。Dinic 算法在链式前向星数据结构上运行，是一种有效的求解网络流的方法。" Dinic 算法是一种经典的求解网络流问题的算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值