[学习笔记] 上下界网络流

已于 2022-07-13 08:45:07 修改
阅读量532 收藏 2
点赞数 2
文章标签： c++
于 2022-03-07 23:10:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LBCLZMB/article/details/123342390
版权

更好的阅读体验？

文章目录

1. 无源汇可行流

1.1. 问题

传送门

1.2. 解决方案

令 u , v u,v u,v 的边为 e e e。我们可以把限制拆成两条：一条固定边边权为 lower ( e ) \text{lower}(e) lower(e)， 另一条边边权为 upper ( e ) − lower ( e ) \text{upper}(e)-\text{lower}(e) upper(e)−lower(e)（我们称其为附加边），这一条直接在原图上连接即可。

怎么判定固定边有没有真的有 lower ( e ) \text{lower}(e) lower(e) 的流量呢？显然如果还是连接 u , v u,v u,v 是无法起到这个效果的。

容易发现固定边可以等价为： u u u 能流出 lower ( e ) \text{lower}(e) lower(e) 且 保持流量守恒， v v v 同理。所以 u , v u,v u,v 之间不必建固定边，只要达到这个效果就行了。

新建源点 S S S，汇点 T T T. 将固定边变成 S S S 向 v v v 连边权为 lower ( e ) \text{lower}(e) lower(e) 的边， u u u 向 T T T 连边权为 lower ( e ) \text{lower}(e) lower(e) 的边。对于某个点，如果固定边的流入总和为 FlowIn ( i ) \text{FlowIn}(i) FlowIn(i)，流出为 FlowOut ( i ) \text{FlowOut}(i) FlowOut(i)，我们将两者减去彼此的较小值，此时相当于消掉了一条边。

接着我们跑一遍 dinic \text{dinic} dinic 的最大流即可，如果满流就找到了一个可行流。可以发现我们将两个限制做了巧妙的转换：对于固定边，满流意味着满足固定边与流量平衡的限制；对于附加边，在起到平衡流量作用的同时也用容量满足附加边的限制。

1.3. 代码

#include <cstdio>

#define rep(i,_l,_r) for(register signed i=(_l),_end=(_r);i<=_end;++i)
#define fep(i,_l,_r) for(register signed i=(_l),_end=(_r);i>=_end;--i)
#define erep(i,u) for(signed i=head[u],v=to[i];i;i=nxt[i],v=to[i])
#define efep(i,u) for(signed i=Head[u],v=to[i];i;i=nxt[i],v=to[i])
#define print(x,y) write(x),putchar(y)

template <class T> inline T read(const T sample) {
    T x=0; int f=1; char s;
    while((s=getchar())>'9'||s<'0') if(s=='-') f=-1;
    while(s>='0'&&s<='9') x=(x<<1)+(x<<3)+(s^48),s=getchar();
    return x*f;
}
template <class T> inline void write(const T x) {
    if(x<0) return (void) (putchar('-'),write(-x));
    if(x>9) write(x/10);
    putchar(x%10^48);
}
template <class T> inline T Max(const T x,const T y) {if(x>y) return x; return y;}
template <class T> inline T Min(const T x,const T y) {if(x<y) return x; return y;}
template <class T> inline T fab(const T x) {return x>0?x:-x;}
template <class T> inline T gcd(const T x,const T y) {return y?gcd(y,x%y):x;}
template <class T> inline T lcm(const T x,const T y) {return x/gcd(x,y)*y;}
template <class T> inline T Swap(T &x,T &y) {x^=y^=x^=y;}

#include <queue>
using namespace std;

const int maxn=205,maxm=10205,inf=0x3f3f3f3f;

queue <int> q;
int n,m,low[maxm],S=0,T,dep[maxn],arc[maxn],Flow[maxn],sum,ans[maxm];
int cnt=1,head[maxn],to[maxm*3],flow[maxm*3],nxt[maxm*3],id[maxm*3];

void addEdge(int u,int v,int w,int ID) {
    nxt[++cnt]=head[u],to[cnt]=v,flow[cnt]=w,id[cnt]=ID,head[u]=cnt;
    nxt[++cnt]=head[v],to[cnt]=u,flow[cnt]=0,id[cnt]=ID,head[v]=cnt;
}

bool bfs() {
    rep(i,0,n+1) dep[i]=inf;
    while(!q.empty()) q.pop();
    q.push(S),arc[S]=head[S],dep[S]=0;
    while(!q.empty()) {
        int u=q.front(); q.pop();
        erep(i,u)
            if(flow[i]>0 && dep[v]==inf) {
                dep[v]=dep[u]+1,arc[v]=head[v];
                q.push(v);
                if(v==T) return 1;
            }
    }
    return 0;
}

int dfs(int u,int CanFlow) {
    if(u==T) return CanFlow;
    int SumFlow=0,d;
    for(int i=arc[u];i;i=nxt[i]) {
        int v=to[i]; arc[u]=i;
        if(flow[i]>0 && dep[v]==dep[u]+1) {
            d=dfs(v,Min(CanFlow,flow[i]));
            if(!d) dep[v]=inf;
            SumFlow+=d,CanFlow-=d;
            flow[i]-=d,flow[i^1]+=d;
            if(!CanFlow) break;
        }
    }
    return SumFlow;
}

int Dinic() {
    int ret=0;
    while(bfs()) ret+=dfs(S,inf);
    return ret;
}

int main() {
    int u,v,x;
    n=read(9),m=read(9); T=n+1;
    rep(i,1,m) {
        u=read(9),v=read(9),low[i]=read(9),x=read(9);
        addEdge(u,v,x-low[i],i); Flow[u]-=low[i],Flow[v]+=low[i];
    }
    rep(i,1,n)
        if(Flow[i]>0) sum+=Flow[i],addEdge(S,i,Flow[i],0);
        else if(Flow[i]<0) addEdge(i,T,-Flow[i],0);
    if(sum==Dinic()) {
        puts("YES");
        rep(i,1,n) erep(j,i) {
            if(!(j&1) || id[j]==0) continue;
            ans[id[j]]=low[id[j]]+flow[j];
        }
        rep(i,1,m) print(ans[i],'\n');
    }
    else puts("NO");
    return 0;
}

2. 有源汇可行流

2.1. 问题

就是在前问题基础上多了源点 s s s 和汇点 t t t.

2.2. 解决方案

在这张图上，显然源汇不需要保证流量平衡，但需要保证 s s s 的流出量等于 t t t 的流入量。为了套上上文那个模型，可以从 t t t 向 s s s 连一条容量为 + ∞ +\infty +∞ 的边，此时我们就保证了 t t t 的流出量等于 s s s 的流入量，从而保证了 s s s 的流出量等于 t t t 的流入量！这样模型成功完成了转换，再跑一遍最大流，那么满流等价于所有除了 S , T S,T S,T 的点流量平衡。

另外，再讲一个我犯过的错误思路：在建图时，扔掉 S , T S,T S,T，将有关 S , T S,T S,T 的边都接到相应的 s , t s,t s,t 上。这个思路在 POJ - 2396 \text{POJ - 2396} POJ - 2396 中是能够通过的，但是在模板题中可以被一个小数据轻松 hack \text{hack} hack 掉：

4 4 1 4
1 2 2 4
1 3 1 3
3 2 1 5
2 4 0 5

这是因为在 POJ - 2396 \text{POJ - 2396} POJ - 2396 中源汇点 s , t s,t s,t 本来就是虚构的，它们之间 没有附加边，所以这样建图实际上和正确的建图方式是等价的。而在模板题中， s , t s,t s,t 之间存在附加边，所以满流不再与满足固定边与流量平衡的限制等价，所以无论求可行流还是下文要讲的最大流都是错误的。

3. 有源汇最大流

3.1. 问题

传送门

3.2. 解决方案

在 2.2. 解决方案 的基础上再跑一遍从 s s s 到 t t t 的最大流（注意，这里 无需重新建图），输出这个最大流。

看上去非常不合理，但这竟然是对的，为什么捏？首先， FlowOut ( t ) = 0 , FlowIn ( t ) > 0 \text{FlowOut}(t)=0,\text{FlowIn}(t)>0 FlowOut(t)=0,FlowIn(t)>0，那么按 lower ( e ) \text{lower}(e) lower(e) 建图时，连向 t t t 的边（其实就是 S → t S\rightarrow t S→t 的那一条）就没有抵消的作用，相当于 t t t 至少接收的流量。此时 t t t 的入边只剩下附加边，跑可行流时相当于调整流量平衡需要接收的流量。

综上可以得出，在跑完可行流后， t t t 流入的流量就是可行流，而 t → s t\rightarrow s t→s 这条边的反边此时就代表这个数值！现在跑一遍从 s s s 到 t t t 的最大流，沿着反边可以统计可行流，而且此时关于 S , T S,T S,T 的边都已经流满了，所以相当于在残余网络上跑最大流，由网络流基本定理，这两项相加就是我们要求的最大流。

3.3. 代码

#include <cstdio>

#define rep(i,_l,_r) for(register signed i=(_l),_end=(_r);i<=_end;++i)
#define fep(i,_l,_r) for(register signed i=(_l),_end=(_r);i>=_end;--i)
#define erep(i,u) for(signed i=head[u],v=to[i];i;i=nxt[i],v=to[i])
#define efep(i,u) for(signed i=Head[u],v=to[i];i;i=nxt[i],v=to[i])
#define print(x,y) write(x),putchar(y)

template <class T> inline T read(const T sample) {
    T x=0; int f=1; char s;
    while((s=getchar())>'9'||s<'0') if(s=='-') f=-1;
    while(s>='0'&&s<='9') x=(x<<1)+(x<<3)+(s^48),s=getchar();
    return x*f;
}
template <class T> inline void write(const T x) {
    if(x<0) return (void) (putchar('-'),write(-x));
    if(x>9) write(x/10);
    putchar(x%10^48);
}
template <class T> inline T Max(const T x,const T y) {if(x>y) return x; return y;}
template <class T> inline T Min(const T x,const T y) {if(x<y) return x; return y;}
template <class T> inline T fab(const T x) {return x>0?x:-x;}
template <class T> inline T gcd(const T x,const T y) {return y?gcd(y,x%y):x;}
template <class T> inline T lcm(const T x,const T y) {return x/gcd(x,y)*y;}
template <class T> inline T Swap(T &x,T &y) {x^=y^=x^=y;}

#include <queue>
using namespace std;

const int maxn=205,maxm=10205,inf=0x3f3f3f3f;

queue <int> q;
int n,m,low[maxm],S=0,T,dep[maxn],arc[maxn],Flow[maxn],sum,ans[maxm];
int cnt=1,head[maxn],to[maxm*3],flow[maxm*3],nxt[maxm*3];

void addEdge(int u,int v,int w) {
    nxt[++cnt]=head[u],to[cnt]=v,flow[cnt]=w,head[u]=cnt;
    nxt[++cnt]=head[v],to[cnt]=u,flow[cnt]=0,head[v]=cnt;
}

bool bfs(int s,int t) {
    rep(i,0,n+1) dep[i]=inf;
    while(!q.empty()) q.pop();
    q.push(s),arc[s]=head[s],dep[s]=0;
    while(!q.empty()) {
        int u=q.front(); q.pop();
        erep(i,u)
            if(flow[i]>0 && dep[v]==inf) {
                dep[v]=dep[u]+1,arc[v]=head[v];
                q.push(v);
                if(v==t) return 1;
            }
    }
    return 0;
}

int dfs(int u,int t,int CanFlow) {
    if(u==t) return CanFlow;
    int SumFlow=0,d;
    for(int i=arc[u];i;i=nxt[i]) {
        int v=to[i]; arc[u]=i;
        if(flow[i]>0 && dep[v]==dep[u]+1) {
            d=dfs(v,t,Min(CanFlow,flow[i]));
            if(!d) dep[v]=inf;
            SumFlow+=d,CanFlow-=d;
            flow[i]-=d,flow[i^1]+=d;
            if(!CanFlow) break;
        }
    }
    return SumFlow;
}

int Dinic(int s,int t) {
    int ret=0;
    while(bfs(s,t)) ret+=dfs(s,t,inf);
    return ret;
}

int main() {
    int u,v,x,s,t;
    n=read(9),m=read(9),s=read(9),t=read(9); T=n+1;
    rep(i,1,m) {
        u=read(9),v=read(9),low[i]=read(9),x=read(9);
        addEdge(u,v,x-low[i]); Flow[u]-=low[i],Flow[v]+=low[i];
    }
    rep(i,1,n)
        if(Flow[i]>0) sum+=Flow[i],addEdge(S,i,Flow[i]);
        else if(Flow[i]<0) addEdge(i,T,-Flow[i]);
    addEdge(t,s,inf);
    if(sum==Dinic(S,T)) print(Dinic(s,t),'\n');
    else puts("please go home to sleep");
    return 0;
}

4. 有源汇最小流

4.1. 问题

传送门

4.2. 解决方案

根据上文的铺垫，在 2.2. 解决方案 的基础上，我们得到了从 s s s 到 t t t 的可行流，先将它记录为 P P P. 再删除从 t t t 到 s s s 的双向边，再跑一遍从 t t t 到 s s s 的最大流。相当于在可行流上进行退流操作，显然要退最多的。

4.3. 代码

#include <cstdio>

#define rep(i,_l,_r) for(register signed i=(_l),_end=(_r);i<=_end;++i)
#define fep(i,_l,_r) for(register signed i=(_l),_end=(_r);i>=_end;--i)
#define erep(i,u) for(signed i=head[u],v=to[i];i;i=nxt[i],v=to[i])
#define efep(i,u) for(signed i=Head[u],v=to[i];i;i=nxt[i],v=to[i])
#define print(x,y) write(x),putchar(y)

template <class T> inline T read(const T sample) {
    T x=0; int f=1; char s;
    while((s=getchar())>'9'||s<'0') if(s=='-') f=-1;
    while(s>='0'&&s<='9') x=(x<<1)+(x<<3)+(s^48),s=getchar();
    return x*f;
}
template <class T> inline void write(const T x) {
    if(x<0) return (void) (putchar('-'),write(-x));
    if(x>9) write(x/10);
    putchar(x%10^48);
}
template <class T> inline T Max(const T x,const T y) {if(x>y) return x; return y;}
template <class T> inline T Min(const T x,const T y) {if(x<y) return x; return y;}
template <class T> inline T fab(const T x) {return x>0?x:-x;}
template <class T> inline T gcd(const T x,const T y) {return y?gcd(y,x%y):x;}
template <class T> inline T lcm(const T x,const T y) {return x/gcd(x,y)*y;}
template <class T> inline T Swap(T &x,T &y) {x^=y^=x^=y;}

#include <queue>
using namespace std;
typedef long long ll;

const int maxn=5e4+5,maxm=125005,inf=0x3f3f3f3f;
const ll infty=1e15;

queue <int> q;
ll Flow[maxn],flow[maxm*3],sum;
int n,m,low[maxm],S=0,T,dep[maxn],arc[maxn];
int cnt=1,head[maxn],to[maxm*3],nxt[maxm*3];

void addEdge(int u,int v,ll w) {
    nxt[++cnt]=head[u],to[cnt]=v,flow[cnt]=w,head[u]=cnt;
    nxt[++cnt]=head[v],to[cnt]=u,flow[cnt]=0,head[v]=cnt;
}

bool bfs(int s,int t) {
    rep(i,0,n+1) dep[i]=inf;
    while(!q.empty()) q.pop();
    q.push(s),arc[s]=head[s],dep[s]=0;
    while(!q.empty()) {
        int u=q.front(); q.pop();
        erep(i,u)
            if(flow[i]>0 && dep[v]==inf) {
                dep[v]=dep[u]+1,arc[v]=head[v];
                q.push(v);
                if(v==t) return 1;
            }
    }
    return 0;
}

ll dfs(int u,int t,ll CanFlow) {
    if(u==t) return CanFlow;
    ll SumFlow=0,d;
    for(int i=arc[u];i;i=nxt[i]) {
        int v=to[i]; arc[u]=i;
        if(flow[i]>0 && dep[v]==dep[u]+1) {
            d=dfs(v,t,Min(CanFlow,flow[i]));
            if(!d) dep[v]=inf;
            SumFlow+=d,CanFlow-=d;
            flow[i]-=d,flow[i^1]+=d;
            if(!CanFlow) break;
        }
    }
    return SumFlow;
}

ll Dinic(int s,int t) {
    ll ret=0;
    while(bfs(s,t)) ret+=dfs(s,t,infty);
    return ret;
}

int main() {
    int u,v,x,s,t; ll tmp;
    n=read(9),m=read(9),s=read(9),t=read(9); T=n+1;
    rep(i,1,m) {
        u=read(9),v=read(9),low[i]=read(9),x=read(9);
        addEdge(u,v,x-low[i]); Flow[u]-=low[i],Flow[v]+=low[i];
    }
    rep(i,1,n)
        if(Flow[i]>0) sum+=Flow[i],addEdge(S,i,Flow[i]);
        else if(Flow[i]<0) addEdge(i,T,-Flow[i]);
    addEdge(t,s,infty);
    if(sum==Dinic(S,T)) {
        tmp=flow[cnt];
        flow[cnt]=flow[cnt-1]=0;
        print(tmp-Dinic(t,s),'\n');
    }
    else puts("please go home to sleep");
    return 0;
}

4.4. 一个奇怪的点

在 LOJ \text{LOJ} LOJ 上有一个 Discussion \text{Discussion} Discussion，它先开始没有引起我的注意……直到我交了 n n n 发另一道板子题， wa \text{wa} wa 得人神共愤 qwq.

在原图上 t t t 就能到达 s s s 时会出现问题：这是因为我们的本意是进行退流，然而这条边其实开始时根本没有流量！或者说，即使有流量也可以看作是 t → s t\rightarrow s t→s 的那条容量为 i n f t y \rm infty infty 的边的贡献。当然按 “流可以为负” 来理解就是正确的😃。

可是，大多数题目要求流量不为负，怎么办呢？你可以再新建一对源汇 s s , t t ss,tt ss,tt，从 s s ss ss 到 s s s、 t t t 到 t t tt tt 连一条容量为 infty \text{infty} infty 的边！好处就是从 t t → s s tt\rightarrow ss tt→ss 的必经之路 —— t t → t tt\rightarrow t tt→t（一条反边）一定只执行退流操作，不存在 i n f t y \rm infty infty 边的干扰了！ Solved \color{LimeGreen}{\text{Solved}} Solved！

或者，你可以将最后的部分换一下：

int Flow = dinic();
addEdge(t,s,inf);
Flow += dinic();
if(sm==Flow) print(e[cnt].w,'\n');

我也不知道为什么是对的，也懒得想了，拜拜。

5. 一些题目

例 1. [ZJOI 2011]  \text{[ZJOI 2011] } [ZJOI 2011] 营救皮卡丘

首先可以将题意转化成：将 n n n 个点划分成 k k k 个可空集合，每个集合 S i S_i Si​ 包含第 i i i 个人摧毁的据点，要求所有集合的交集为空，并集为全集。显然，对于第 i i i 个人，从 u u u 到 v v v 的花费是 dis ( u , v ) \text{dis}(u,v) dis(u,v)，其中 dis ( u , v ) \text{dis}(u,v) dis(u,v) 是从 u u u 开始，不经过 > max ⁡ { u , v } >\max\{u,v\} >max{u,v} 的点的最短路。

这是因为我们总能找到一个移动人物的顺序，使得其满足 “先摧毁前 1 1 1 到 k − 1 k-1 k−1 个据点，再摧毁第 k k k 个据点” 的限制。

类似路径覆盖的问题，可以考虑用网络流解决。将每个人行走的路径看作一条流，那么网络流图上的边实际上就是两点之间的路径。

接着考虑需要满足什么限制：流量小于等于 k k k；每个点都至少被经过一次。可以发现，“交集为空” 的限制实际上没有用。

第一个限制可以建源点，连 s s → 1 ss\rightarrow 1 ss→1（点从 1 1 1 开始编号，令 n = N + 1 n=N+1 n=N+1）的容量为 k k k 的边；对于第二条限制，可以利用经典的 “拆点为边” 思想，拆成出/入点，再限制拆出的边流量至少为 1 1 1。对于据点之间，就用出点连入点即可。最后，将出点连向 t t tt tt，表示路径可以在任意节点终止；将 1 1 1 连向入点，费用为 dis ( 1 , i ) \text{dis}(1,i) dis(1,i).

我们得到了朴素网络流图，现在需要满足 “流量至少为 1 1 1” 的限制，也即再转化成上下界网络流。可以发现此模型是 2. 有源汇可行流，而非最大流，所以需要建立 循环流，即从 t t tt tt 向 s s ss ss 连容量为 i n f t y \rm infty infty 的边。然后新建 S , T S,T S,T，朴素上下界连边即可。

另外，对于这类最少代价路径覆盖还有另一种解决方案 —— 二分图匹配。以下先以 [SDOI 2010]  \text{[SDOI 2010] } [SDOI 2010] 星际竞速 为例。

还是建出源汇，将每个点拆分成出点 i i i（左部点）与入点 i ′ i' i′（右部点）， S S S 向左部连容量为 1 1 1 的边， T T T 向右部连容量为 1 1 1 的边。对于其它边，类似证明 “最小路径覆盖 = = = 点数 − - − 最大匹配数” 这个结论，我们假设初始状态有 n n n 条路径，那么总代价是 ∑ a i \sum a_i ∑ai​. 一个匹配对应减少一条路径，假设 i i i 与 j ′ j' j′ 匹配，就意味着 i → j i\rightarrow j i→j 变成某条路径上 连续 的两点，此时减去 a j a_j aj​（不能减去 a i a_i ai​ 的原因请自行思考），所以匹配贡献是 w ( i , j ) − a j w(i,j)-a_j w(i,j)−aj​，并令其容量为 1 1 1. 用这张图跑 F F \mathtt{FF} FF 算法，选择最短路小于零的流加入 a n s \rm ans ans，如果最短路大于等于零可以直接终止。

不难发现每个点至多只会前后各匹配一次，所以正确性保证。

回到这道题，难搞的其实是 k k k 个人的限制，我们发现这其实就是强制要求进行 N − k N-k N−k 次匹配，并且忽略点 1 1 1，于是这道题就做完了。代码简单而且思路非常好理解，比上下界快到不知道哪里去了 /kk.

Vizayho
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
浅谈上下界网络流
linkfqy
07-07 4920
背景最近一直在做这类题目…… 感觉题目变化还是挺多的 就在这里总结一下好了……首先Orz Lynstery 本文参考博客：有上下界的网络流学习笔记——by liu_runda正文上下界网络流，显然就是对每条边有上下界流量限制的网络流问题 众人：这不废话嘛 对于上下界网络流问题，最重要的思想是“转化” 因为学习后你会发现：处理每一种情形都是要由前一种更为简单的情形转化过来，然后用同样的方法
有上下界的网络流
a302549450的博客
02-07 293
有上下界的网络流具体可以分为以下三种： 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条水管的流量满足条件，如果存在，则输出每...
【学习笔记】上下界网络流
七代目鸽影
02-06 259
昨天刚刚被神秘建图方式打败了。今天又发现连知识点都没学完……
【ALGO】网络流(5) 上下界网络流
0x00
07-28 353
上下界网络流例题解析
上下界网络流
weixin_30466421的博客
05-28 137
目录 无源汇有上下界可行流 有源汇有上下界可行流 有源汇有上下界最大流 有源汇有上下界最小流 无源汇有上下界最小费用可行流 有源汇有上下界最小费用可行流 有源汇有上下界最小费用最大流 有源汇有上下界最小费用最小流 ...
网络编程学习笔记.md
05-08
网络编程 （狂神说Java）学习笔记 + 自己的一些理解
计算机网络 自顶向下方法 学习笔记 复习.docx
12-30
计算机网络 自顶向下方法 学习笔记 期末复习
计算机网络技术学习笔记
12-26
这是我自己总结的适合于中等职业院校升学考试的文档，有了它，计算机网络技术这门课，稳过，不挂科。 本着学习、成长、沉淀、分享的原则，将其上传到这个平台，供大家参考。 本人水平有限，文档里难免有错误的地方，...
计算机网络学习笔记.zip
10-25
该资源适合于计算机网络初学者进行学习和参考，由于该笔记是.md格式的文件，所以需要用专门的软件（如typroa等支持.md文件的软件打开）进行学习和参考
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
5.有上下界的网络流_有上下界的网络流_
10-03
有上下界的网络流分别称为流量限制条件和流量平衡条件 而在有上下界的网络流图中，由于多了流量下界b(uv) 的限制，满足
浅谈有上下界的网络流问题
偶耶的博客
11-04 446
无源汇/有源汇·有上下界·可行流/最大流/最小流，全程无公式的通俗口胡。强大的工具只要会用就行，并不需要很了解其中的原理
有上下界网络流问题
weixin_34387284的博客
02-27 85
转自：http://www.cnblogs.com/kane0526/archive/2013/04/05/3001108.html 此类问题可以分为三小类问题： 一、无源汇有上下界最大流 二、有源汇有上下界最大流 三、有源汇有上下界最小流 1、无源汇有上下界最大流 题目链接：sgu194Reactor Cooling 题目大...
无源汇有上下界可行流（网络流进阶）
weixin_30349597的博客
06-16 361
无源汇有上下界可行流(也就是循环流) 模型:一个网络,求出一个流,使得每条边的流量必须>=Li且<=Hi, 每个点必须满足总流入量=总流出量(流量守恒)(这个流的特点是循环往复,无始无终) 可行流算法的核心是将一个不满足流量守恒的初始流调整成满足流量守恒的流 流量守恒,即每个点的总流入量=总流出量 如果存在一个可行流,那么一定满足每条边的流量...
带上下界的网络流
weixin_40588429的博客
11-14 181
对于每条边加了个下界限制B(e)，这样每条边需满足条件B(e) &lt;= F(e) &lt;= C(e)。 1）对于无源点和汇点 对于每一条边e，将其分离成两条边e’和e’’，其中的容量C(e’) = C(e) - B(e)，C(e’’) = B(e) 这样分离后只需要e’'满流即可 步骤：新建源点S和汇点T，对原图的每一条边e = &lt;u, v&gt;，建立从u到v容量C(e) - B(e...
上下界网络流 cf704D
rgndao的博客
04-05 166
cf704D 给棋盘上n个棋子染色，红黑两种，代价不同，有m个约束，要求某一行或某一列的红黑棋子数差不能超过某一数值。求最小代价的染色方案。 上下界网络流的思路就是分别减去最低流量，剩余的放在图中跑最大流，对于原有大于零下界的边就通过新建超级源点ss和汇点tt解决，即出点多出的连向汇点，入点缺少的从源点补充。合法要求：源点s发出的必须能跑满，否则原有的平衡条件就打破了，无可行流。 对于原本就...
【自用】有上下界的网络流
辗转山河弋流歌
04-24 1559
无源汇网络流(有向图)： 最终的最大流需要是一个循环体，流量在内部循环流动。 必须流和自由流的定义： 首先设每条边上界为flow，下界为low，那么就存在low的必须流和flow-low的自由流。 「无源汇」有上下界的「可行」流： 建图： 记录每个点的所有流入的必须流in和所有流出的必须流out。 然后新图先设立一个超级源点和一个超级汇点， 对于每条边，保留其自由流的容
有源汇有上下界的最小流（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、付费专栏及课程。

余额充值