有上下界的网络流问题

最新推荐文章于 2021-11-04 21:03:26 发布
最新推荐文章于 2021-11-04 21:03:26 发布
阅读量721 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011728372/article/details/11765473
版权

此类问题可以分为三小类问题：

一、无源汇有上下界最大流

二、有源汇有上下界最大流

三、有源汇有上下界最小流

关于这个可以参考周源的《一种简易的方法求解流量有上下界的网络中的网络流问题》

1、无源汇有上下界最大流（可行流）

题目链接： sgu194 Reactor Cooling

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

const int MAXV = 222;
const int MAXE = 2*MAXV*MAXV;
const int INF = 0x3f3f3f3f;

struct Edge
{
    int u, v, cap, next;
    Edge() {}
    Edge(int t_u, int t_v, int t_cap, int t_next)\
        : u(t_u), v(t_v), cap(t_cap), next(t_next) {}
};

Edge edges[MAXE];
//int init_cap[MAXE];
int n, m, source, sink, edge_sum, max_flow;
int head[MAXV], dis[MAXV];
int low[MAXE], in[MAXV], out[MAXV];

void Init()
{
    edge_sum = 0;
    memset(head, -1, sizeof(head));
    memset(in, 0, sizeof(in));
    memset(out, 0, sizeof(out));
}

void addEdge(int u, int v, int cap)
{
    edges[edge_sum].u = u;
    edges[edge_sum].v = v;
    edges[edge_sum].cap = cap;
    edges[edge_sum].next = head[u];
    head[u] = edge_sum++;

    edges[edge_sum].u = v;
    edges[edge_sum].v = u;
    edges[edge_sum].cap = 0;
    edges[edge_sum].next = head[v];
    head[v] = edge_sum++;
}

int bfs()
{
    int i, v, tmp;
    queue<int> q;
    memset(dis, 0, sizeof(dis));
    dis[source] = 1;
    q.push(source);
    while(!q.empty())
    {
        v = q.front(); q.pop();
        for(i = head[v]; i != -1; i = edges[i].next)
        {
            tmp = edges[i].v;
            if(!dis[tmp] && edges[i].cap)
            {
                dis[tmp] = dis[v] + 1;
                if(tmp == sink)
                    return 1;
                q.push(tmp);
            }
        }
    }
    return 0;
}

int dfs(int cur, int cp)
{
    if(cur == sink)
        return cp;
    int tmp = 0, i, a, t;
    for(i = head[cur]; i != -1 && tmp < cp; i = edges[i].next)
    {
        a = edges[i].v;
        if(dis[a] == dis[cur]+1 && edges[i].cap)
        {
            t = dfs(a, min(edges[i].cap, cp-tmp));
            edges[i].cap -= t;
            edges[i^1].cap += t;
            tmp += t;
        }
    }
    if(!tmp) dis[cur] = -1;
    return tmp;
}

void dinic()
{
    max_flow = 0;
    while(bfs())
        max_flow += dfs(source, INF);
    return ;
}

int main()
{
    //freopen("aa.in", "r", stdin);
    //freopen("bb.out", "w", stdout);
    int u, v, l, h, tm;

    while(scanf("%d %d", &n, &m) != EOF)
    {
        Init();
        tm = m;
        while(m--)
        {
            scanf("%d %d %d %d", &u, &v, &l, &h);
            //init_cap[edge_sum] = h - l;
            low[edge_sum] = l;
            addEdge(u, v, h - l);
            in[v] += l;
            out[u] += l;
            //low[edge_sum-2] = l;
        }
        source = 0, sink = n + 1;
        for(int i = 1; i <= n; ++i)
        {
            if(in[i] > out[i])
                addEdge(source, i, in[i]-out[i]);
            if(in[i] < out[i])
                addEdge(i, sink, out[i] - in[i]);
        }
        n += 2;
        bool flag = true;
        dinic();
        for(int i = head[source]; i != -1; i = edges[i].next)
        {
            if(edges[i].cap > 0)
            {
                flag = false;
                break;
            }
        }
        if(!flag)
            printf("NO\n");
        else
        {
            printf("YES\n");
            for(int i = 0; i < 2*tm; i += 2)
            {
                printf("%d\n", low[i] + edges[i^1].cap);
                //printf("%d\n", low[i] + init_cap[i]-edges[i].cap);
            }
        }
    }
    return 0;
}

2、有源汇有上下界最大流

题目链接：zoj3229 Shoot the Bullet

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

const int MAXV = 1500;
const int MAXE = 1000010;
const int INF = 0x3f3f3f3f;

struct Edge
{
    int u, v, cap, next;
    Edge() {}
    Edge(int t_u, int t_v, int t_cap, int t_next)\
        : u(t_u), v(t_v), cap(t_cap), next(t_next) {}
};

Edge edges[MAXE];
int n, m, source, sink, edge_sum, max_flow;
int head[MAXV], dis[MAXV];
int du[MAXV];
int low[400][1010], pos[400][1010];


void Init()
{
    edge_sum = 0;
    memset(head, -1, sizeof(head));
    memset(du, 0, sizeof(du));
    memset(low, -1, sizeof(low));
    //memset(in, 0, sizeof(in));
    //memset(out, 0, sizeof(out));
}

void addEdge(int u, int v, int cap)
{
    edges[edge_sum].u = u;
    edges[edge_sum].v = v;
    edges[edge_sum].cap = cap;
    edges[edge_sum].next = head[u];
    head[u] = edge_sum++;

    edges[edge_sum].u = v;
    edges[edge_sum].v = u;
    edges[edge_sum].cap = 0;
    edges[edge_sum].next = head[v];
    head[v] = edge_sum++;
}

int bfs()
{
    int i, v, tmp;
    queue<int> q;
    memset(dis, 0, sizeof(dis));
    dis[source] = 1;
    q.push(source);
    while(!q.empty())
    {
        v = q.front(); q.pop();
        for(i = head[v]; i != -1; i = edges[i].next)
        {
            tmp = edges[i].v;
            if(!dis[tmp] && edges[i].cap)
            {
                dis[tmp] = dis[v] + 1;
                if(tmp == sink)
                    return 1;
                q.push(tmp);
            }
        }
    }
    return 0;
}

int dfs(int cur, int cp)
{
    if(cur == sink)
        return cp;
    int tmp = 0, i, a, t;
    for(i = head[cur]; i != -1 && tmp < cp; i = edges[i].next)
    {
        a = edges[i].v;
        if(dis[a] == dis[cur]+1 && edges[i].cap)
        {
            t = dfs(a, min(edges[i].cap, cp-tmp));
            edges[i].cap -= t;
            edges[i^1].cap += t;
            tmp += t;
        }
    }
    if(!tmp) dis[cur] = -1;
    return tmp;
}

void dinic()
{
    max_flow = 0;
    while(bfs())
        max_flow += dfs(source, INF);
    return ;
}

int main()
{
    //freopen("aa.in", "r", stdin);
    //freopen("bb.out", "w", stdout);

    int t_n, G, C, D, T, L, R;

    while(scanf("%d %d", &n, &m) != EOF)
    {
        Init();
        for(int i = 1; i <= m; ++i)
        {
            scanf("%d", &G);
            addEdge(n + i, n + m + 1, INF - G);
            du[n+i] -= G;
            du[n+m+1] += G;
            //out[n+i] += G;
            //in[n+m+1] += G;
        }
        for(int i = 1; i <= n; ++i)
        {
            scanf("%d %d", &C, &D);
            addEdge(0, i, D);
            for(int j = 1; j <= C; ++j)
            {
                scanf("%d %d %d", &T, &L, &R);
                T++;
                pos[i][T] = edge_sum;
                addEdge(i, n + T, R - L);
                du[i] -= L;
                du[n+T] += L;
                //out[i] += L;
                //in[n+T] += L;
                low[i][T] = L;
            }
        }
        addEdge(n + m + 1, 0, INF);
        source = n + m + 2, sink = n + m + 3;
        for(int i = 0; i <= n + m + 1; ++i)
        {
            if(du[i] > 0)
                addEdge(source, i, du[i]);
            if(du[i] < 0)
                addEdge(i, sink, -du[i]);
            //if(in[i] > out[i])
                //addEdge(source, i, in[i] - out[i]);
            //if(in[i] < out[i])
                //addEdge(i, sink, out[i] - in[i]);
        }
        bool flag = true; t_n = n;
        n = n + m + 4;
        dinic();
        for(int i = head[source]; i != -1; i = edges[i].next)
        {
            if(edges[i].cap > 0)
            {
                flag = false;
                break;
            }
        }
        if(!flag)
        {
            printf("-1\n");
        }
        else
        {
            n -= 2;
            //head[source] = -1, head[sink] = -1;
            source = 0, sink = t_n + m + 1;   //
            dinic();
            printf("%d\n", max_flow);
            for(int i = 1; i <= t_n; ++i)
            {
                for(int j = 1; j <= m; ++j)
                {
                    if(low[i][j] != -1)
                        printf("%d\n", low[i][j] + edges[pos[i][j]^1].cap);
                }
            }
        }
        printf("\n");
    }
    return 0;
}

3、有源汇有上下界最小流

题目链接：   sgu176  Flow construction

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

const int MAXV = 150;
const int MAXE = 2*MAXV*MAXV;
const int INF = 0x3f3f3f3f;

struct Edge
{
    int u, v, cap, next;
    Edge() {}
    Edge(int t_u, int t_v, int t_cap, int t_next)\
        : u(t_u), v(t_v), cap(t_cap), next(t_next) {}
};

Edge edges[MAXE];
int n, m, source, sink, edge_sum, max_flow, t_flow;
int head[MAXV], dis[MAXV];
int in[MAXV], out[MAXV];
int low[MAXE], save[MAXE];

void Init()
{
    edge_sum = 0; t_flow = 0;
    memset(head, -1, sizeof(head));
    memset(in, 0, sizeof(in));
    memset(out, 0, sizeof(out));
    memset(low, 0, sizeof(low));
}

void addEdge(int u, int v, int cap)
{
    edges[edge_sum].u = u;
    edges[edge_sum].v = v;
    edges[edge_sum].cap = cap;
    edges[edge_sum].next = head[u];
    head[u] = edge_sum++;

    edges[edge_sum].u = v;
    edges[edge_sum].v = u;
    edges[edge_sum].cap = 0;
    edges[edge_sum].next = head[v];
    head[v] = edge_sum++;
}

int bfs()
{
    int i, v, tmp;
    queue<int> q;
    memset(dis, 0, sizeof(dis));
    dis[source] = 1;
    q.push(source);
    while(!q.empty())
    {
        v = q.front(); q.pop();
        for(i = head[v]; i != -1; i = edges[i].next)
        {
            tmp = edges[i].v;
            if(!dis[tmp] && edges[i].cap)
            {
                dis[tmp] = dis[v] + 1;
                if(tmp == sink)
                    return 1;
                q.push(tmp);
            }
        }
    }
    return 0;
}

int dfs(int cur, int cp)
{
    if(cur == sink)
        return cp;
    int tmp = 0, i, a, t;
    for(i = head[cur]; i != -1 && tmp < cp; i = edges[i].next)
    {
        a = edges[i].v;
        if(dis[a] == dis[cur]+1 && edges[i].cap)
        {
            t = dfs(a, min(edges[i].cap, cp-tmp));
            edges[i].cap -= t;
            edges[i^1].cap += t;
            tmp += t;
        }
    }
    if(!tmp) dis[cur] = -1;
    return tmp;
}

void dinic()
{
    max_flow = 0;
    while(bfs())
        max_flow += dfs(source, INF);
    return ;
}

int Binary_search(int l, int r)
{
    int mid, ans = -1;

    while(l <= r)
    {
        mid = (l + r) / 2;
        edges[head[n-2]].cap = mid;
        edges[head[n-2]^1].cap = 0;
        dinic();
        if(max_flow == t_flow)
        {
            //cout << max_flow << " " << t_flow << endl;
            r = mid - 1;
            ans = mid;
        }
        else
            l = mid + 1;
        for(int i = 0; i < edge_sum; ++i)
        {
            edges[i].cap = save[i];
        }
    }
    if(ans != -1)
    {
        edges[head[n-2]].cap = ans;
        edges[head[n-2]^1].cap = 0;
        dinic();
    }
    return ans;
}

int main()
{
    //freopen("aa.in", "r", stdin);
    //freopen("bb.out", "w", stdout);

    int u, v, z, c;

    while(scanf("%d %d", &n, &m) != EOF)
    {
        Init();
        for(int i = 1; i <= m; ++i)
        {
            scanf("%d %d %d %d", &u, &v, &z, &c);
            if(c == 0)
            {
                addEdge(u, v, z);
            }
            else if(c == 1)
            {
                t_flow += z;   
                low[edge_sum] = z;
                in[v] += z;
                out[u] += z;
                addEdge(u, v, 0);
            }
        }
        source = 0, sink = n + 1;
        for(int i = 1; i <= n; ++i)
        {
            addEdge(source, i, in[i]);
            addEdge(i, sink, out[i]);
        }
        addEdge(n, 1, INF); n += 2;    
        for(int i = 0; i < edge_sum; ++i)
        {
            save[i] = edges[i].cap;
        }
        int l = 0, r = INF;
        int ans = Binary_search(l, r);
        if(ans == -1)
        {
            printf("Impossible\n");
        }
        else
        {
            printf("%d\n", ans);
            for(int i = 0; i < 2*m; i += 2)
            {
                if(i == 0)
                    printf("%d", low[i]+edges[i^1].cap);
                else
                    printf(" %d", low[i]+edges[i^1].cap);
            }
            printf("\n");
        }
    }
    return 0;
}

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

const int MAXV = 150;
const int MAXE = 2*MAXV*MAXV;
const int INF = 0x3f3f3f3f;

struct Edge
{
    int u, v, cap, next;
    Edge() {}
    Edge(int t_u, int t_v, int t_cap, int t_next)\
        : u(t_u), v(t_v), cap(t_cap), next(t_next) {}
};

Edge edges[MAXE];
int n, m, source, sink, edge_sum, max_flow, t_flow;
int head[MAXV], dis[MAXV];
int in[MAXV], out[MAXV];
int low[MAXE];

void Init()
{
    edge_sum = 0; t_flow = 0;
    memset(head, -1, sizeof(head));
    memset(in, 0, sizeof(in));
    memset(out, 0, sizeof(out));
    memset(low, 0, sizeof(low));
}

void addEdge(int u, int v, int cap)
{
    edges[edge_sum].u = u;
    edges[edge_sum].v = v;
    edges[edge_sum].cap = cap;
    edges[edge_sum].next = head[u];
    head[u] = edge_sum++;

    edges[edge_sum].u = v;
    edges[edge_sum].v = u;
    edges[edge_sum].cap = 0;
    edges[edge_sum].next = head[v];
    head[v] = edge_sum++;
}

int bfs()
{
    int i, v, tmp;
    queue<int> q;
    memset(dis, 0, sizeof(dis));
    dis[source] = 1;
    q.push(source);
    while(!q.empty())
    {
        v = q.front(); q.pop();
        for(i = head[v]; i != -1; i = edges[i].next)
        {
            tmp = edges[i].v;
            if(!dis[tmp] && edges[i].cap)
            {
                dis[tmp] = dis[v] + 1;
                if(tmp == sink)
                    return 1;
                q.push(tmp);
            }
        }
    }
    return 0;
}

int dfs(int cur, int cp)
{
    if(cur == sink)
        return cp;
    int tmp = 0, i, a, t;
    for(i = head[cur]; i != -1 && tmp < cp; i = edges[i].next)
    {
        a = edges[i].v;
        if(dis[a] == dis[cur]+1 && edges[i].cap)
        {
            t = dfs(a, min(edges[i].cap, cp-tmp));
            edges[i].cap -= t;
            edges[i^1].cap += t;
            tmp += t;
        }
    }
    if(!tmp) dis[cur] = -1;
    return tmp;
}

void dinic()
{
    max_flow = 0;
    while(bfs())
        max_flow += dfs(source, INF);
    return ;
}

int main()
{
    //freopen("aa.in", "r", stdin);
    //freopen("bb.out", "w", stdout);

    int u, v, z, c;
    int ans;

    while(scanf("%d %d", &n, &m) != EOF)
    {
        Init();
        for(int i = 1; i <= m; ++i)
        {
            scanf("%d %d %d %d", &u, &v, &z, &c);
            if(c == 0)
            {
                addEdge(u, v, z);
            }
            else if(c == 1)
            {
                t_flow += z;
                low[edge_sum] = z;
                out[u] += z;
                in[v] += z;
                addEdge(u, v, 0);
            }
        }
        source = 0, sink = n + 1;
        for(int i = 1; i <= n; ++i)
        {
            addEdge(source, i, in[i]);
            addEdge(i, sink, out[i]);
        }
        addEdge(n, 1, INF);

        n += 2; dinic();
        ans = edges[head[n-2]^1].cap;

        if(max_flow != t_flow)
        {
            printf("Impossible\n");
        }
        else
        {
            edges[head[n-2]].cap = 0;
            edges[head[n-2]^1].cap = 0;

            n -= 2;
            source = n, sink = 1;
            dinic();
            ans -= max_flow;


            if(ans < 0)
            {
                edges[head[n]].cap = 0;
                edges[head[n]^1].cap = 0;
                addEdge(0, 1, -ans);
                //edges[edge_sum].u = 0;
                //edges[edge_sum].v = 1;
                //edges[edge_sum].cap = -ans;
                //edges[edge_sum].next = head[0];
                //head[0] = edge_sum++;
                source = 0, sink = n; n++;
                dinic();
                ans = 0;
            }
            printf("%d\n", ans);
            bool first = true;
            for(int i = 0; i < 2*m; i += 2)
            {
                if(first)
                {
                    first = false;
                    printf("%d", low[i]+edges[i^1].cap);
                }
                else
                    printf(" %d", low[i]+edges[i^1].cap);
            }
            printf("\n");
        }
    }
    return 0;
}



DDY92
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
周源-有上下界的网络流周源-有上下界的网络流
10-01
周源-有上下界的网络流周源-有上下界的网络流周源-有上下界的网络流周源-有上下界的网络流
[学习笔记] 上下界网络流
Oxide‘s Blog
03-07 522
上下界网络流。
【学习笔记】上下界网络流
七代目鸽影
02-06 233
昨天刚刚被神秘建图方式打败了。今天又发现连知识点都没学完……
上下界网络流
zmh的博客
03-01 580
一：概述 一般的网络流模型中对边只有上界的限制，及流过该边的流量不超过上界。上下界网络流的不同之处在于，每条边还有一个下界，即流过该边的流量不少于下界。其实一般的网络流也可以看做下界为0。 上下界网络流的模型可以分为以下几种类型： 1.无源汇的上下界可行流：没有源点和汇点，要求一组满足流量限制的可行流。 2.有源汇的上下界最大流：有源点和汇点，求满足流量限制的最大流。 3.有源汇的上下界
有上下界的网络流算法汇总
cj1064789374的博客
12-31 1066
有上下界的网络流算法汇总 零、预备知识 f(u,v)表示u-&gt;v这条边的实际流量 b(u,v)表示u-&gt;v这条边的流量下界 c(u,v)表示u-&gt;v这条边的流量上界 在无源汇普通网络流图中满足       在有上下界的网络流图中多了流量下界b(u,v)故需满足 0≤f(u,v)≤c(u,v) 流量限制条件     b(u,v)≤f(u,v)≤c(u,v) 流量限制条件...
有上下界网络流问题
11-26
若在流网络的每条边加上两个限制条件，即low和up，low代表此边流量的下界，up代表此边的流量上界，求源点到汇点的最大流。
5.有上下界的网络流_有上下界的网络流_
10-03
有上下界的网络流分别称为流量限制条件和流量平衡条件 而在有上下界的网络流图中，由于多了流量下界b(uv) 的限制，满足
一种简易的方法求解流量有上下界的网络中网络流问题
02-06
研究命题 一般的，定义一个网络是一个加权的有向图G = (V, E, C)，E 中的每条弧(u, v)都有一个 容量上界C(u, v)≥0。 如果人为的规定V 中的两个点s 和t，其中s 没有入度而t 没有...这样G 就是一个容量有上下界的流网络
有上下界的网络流学习笔记
weixin_30824479的博客
01-08 124
//其实主要还是自己复习用 //假定读者能够熟练打dinic的板子 有上下界的网络流的核心是”调整”,我们通过一个初始的未必可行的流调整出一个可行流,还可以从可行的未必最大/最小的流调整出最大/最小流. 另一个常用技巧是有源汇的流和无源汇的流(循环流)的转换.除了无源汇可行流的求解,其他有源汇的上下界网络流都要用到这个技巧. 无源汇有上下界可行流(也就是循环流) 模型:一个网络,...
浅谈上下界网络流
linkfqy
07-07 4864
背景最近一直在做这类题目…… 感觉题目变化还是挺多的 就在这里总结一下好了……首先Orz Lynstery 本文参考博客：有上下界的网络流学习笔记——by liu_runda正文上下界网络流，显然就是对每条边有上下界流量限制的网络流问题 众人：这不废话嘛 对于上下界网络流问题，最重要的思想是“转化” 因为学习后你会发现：处理每一种情形都是要由前一种更为简单的情形转化过来，然后用同样的方法
【ALGO】网络流(5) 上下界网络流
0x00
07-28 347
上下界网络流例题解析
上下界网络流模型
秋叶红于二月花
05-10 255
前言 上下界网络流是指每条边的容量限制除了上线之外，还有一个下限。 5月10日更新：先放做法，原理日后再说 注意： 附加源和附加汇取名SS和TT是为了与源汇S和T相区别。 “边”和“弧”分别代指题目给定的有向图中的边，和自建网络中的边。 一. 无源汇上下界可行流 没有源点和汇点，因为流量下限的存在，网络中形成了一个封闭的循环流。 做法： 新建附加源SSSSSS，附加汇TTTTTT. 设节点u...
浅谈有上下界的网络流问题
偶耶的博客
11-04 409
无源汇/有源汇·有上下界·可行流/最大流/最小流，全程无公式的通俗口胡。强大的工具只要会用就行，并不需要很了解其中的原理
有上下界的网络流
a302549450的博客
02-07 275
有上下界的网络流具体可以分为以下三种： 1.无源汇有上下界可行流 例题：ZOJ - 2314 题意：有 nnn 个节点，且有 mmm 条水管，每条水管的流向为单向，且每条水管的流量有限制，第 iii 条水管的流量 fi(li≤fi≤ci)f_i(l_i \leq f_i \leq c_i)fi​(li​≤fi​≤ci​) ，问是否存在一种流量分配，使得这m条水管的流量满足条件，如果存在，则输出每...
上下界网络流学习
StaroForgin的博客
02-06 178
上下界网络流 其实之前也写过博客介绍过的，但还没有完整地讲过一遍，这里就来总结一下。 无源汇有上下界可行流 针对任何的有上下界的网络流的边，我们考虑将它转化一下。
上下界网络流总结
araw94333的博客
07-24 108
前言 最近发现网络流很菜,所以就做点题目练练手. 无源汇上下界可行流 题面 我们不妨先把所有的边的容量设为\([0,upp-low]\),那么这个时候显然一条边的实际流量应该是\(flow_i+low_i\)对吧. 我们对于新建的图跑流,肯定是能够保证\(flow_i\)平衡,但是我们无法保证\(flow_i+low_i\)平衡,这时我们引入一个\(delta\)数组. 对于\(delt...
有源汇有上下界的最小流（LOJ117）
最新发布
06-11
这是一个IT类问题。该问题可以使用网络流算法解决。首先用 Dinic 或 ISAP 算法求出最大流，然后根据最大流的值和边的上下界，构造一个新图，使得原图中的每条边都对应着新图中的一些流量限制。具体地，对于一条容量为$c$，下界为$l$，上界为$u$的边$(u,v)$，我们在新图中从$u$向$v$连一条容量为$u-l$的边和一条容量为$u-l$，费用为$c$的边，再从源点向$u$连一条容量为$l$的边，费用为$0$，最后从$v$向汇点连一条容量为$l$的边，费用为$0$。在新图上跑一遍费用流，如果总流量等于原图的最大流，则新图中的最小费用即为所求最小流，否则原图不存在满足上下界的流。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值