上下界的网络流模板

上下界网络流问题对于每一条边、都有流量上下限的限制

而普通的网络流就只有上限限制

下面分别给出几种经典上下界网络流问题的模板

参考博文Ⅰ、参考博文Ⅱ

1、无源汇的上下界可行流

实际也就是能否找出一个循环流、使得每个点的流入总流量 == 流出总流量

对于原图的每一条边在网络流中容量应当为（上界 - 下界）

而后计算每个点流入流量的下界总和记为 in 、流出流量的下界总和记为 out

抽象出超级源汇 ss 与 tt

对于原图中的每一个点

如果 in - out > 0 则 ss 与这个点连边、容量为 in - out

如果 in - out < 0 则这个点与 tt 连边、容量为 out - in

最后如果 ss 的出边都满流的话、说明可行

给出建图伪代码

for each v in Graph

if( in[v] - out[v] ) connect ss -> v、cap = in[v] - out[v]、FlowSum += in[v] - out[v]

else if( in[v] - out[v] ) connect v -> tt、cap = out[v] - in[v]

最后如果最大流 == FlowSum 则说明可行、否则不行

LOJ 115 上下界可行流模板题

#include<bits/stdc++.h>
#define LL long long
#define ULL unsigned long long

#define scl(i) scanf("%lld", &i)
#define scll(i, j) scanf("%lld %lld", &i, &j)
#define sclll(i, j, k) scanf("%lld %lld %lld", &i, &j, &k)
#define scllll(i, j, k, l) scanf("%lld %lld %lld %lld", &i, &j, &k, &l)

#define scs(i) scanf("%s", i)
#define sci(i) scanf("%d", &i)
#define scd(i) scanf("%lf", &i)
#define scIl(i) scanf("%I64d", &i)
#define scii(i, j) scanf("%d %d", &i, &j)
#define scdd(i, j) scanf("%lf %lf", &i, &j)
#define scIll(i, j) scanf("%I64d %I64d", &i, &j)
#define sciii(i, j, k) scanf("%d %d %d", &i, &j, &k)
#define scddd(i, j, k) scanf("%lf %lf %lf", &i, &j, &k)
#define scIlll(i, j, k) scanf("%I64d %I64d %I64d", &i, &j, &k)
#define sciiii(i, j, k, l) scanf("%d %d %d %d", &i, &j, &k, &l)
#define scdddd(i, j, k, l) scanf("%lf %lf %lf %lf", &i, &j, &k, &l)
#define scIllll(i, j, k, l) scanf("%I64d %I64d %I64d %I64d", &i, &j, &k, &l)

#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1
#define lowbit(i) (i & (-i))
#define mem(i, j) memset(i, j, sizeof(i))

#define fir first
#define sec second
#define VI vector<int>
#define ins(i) insert(i)
#define pb(i) push_back(i)
#define pii pair<int, int>
#define VL vector<long long>
#define mk(i, j) make_pair(i, j)
#define all(i) i.begin(), i.end()
#define pll pair<long long, long long>

#define _TIME 0
#define _INPUT 0
#define _OUTPUT 0
clock_t START, END;
void __stTIME();
void __enTIME();
void __IOPUT();
using namespace std;

const int maxn = 2000;
const int maxm = (10405) << 1;
struct Edge{
    int x,y,nxt;
    LL cap;
    Edge(){}
    Edge(int a,int b,LL c,LL d)
    { x=a,y=b,cap=c,nxt=d; }
};

struct Dinic{
    static const int N=maxn, M=maxm;
    static const LL INF=0x7fffffff;
    Edge e[M];
    int n,S,T,fst[N],cur[N],EdgeCnt;
    int q[N],dis[N],head,tail;
    LL MaxFlow;

    void Clear(int _n){
        n=_n,EdgeCnt=1;
        memset(fst,0,sizeof fst);
    }
    void AddEdge(int a,int b,LL c){
        e[++EdgeCnt]=Edge(a,b,c,fst[a]),fst[a]=EdgeCnt;
        e[++EdgeCnt]=Edge(b,a,0,fst[b]),fst[b]=EdgeCnt;
    }
    void init(){
        for (int i=1;i<=n;i++)
            cur[i]=fst[i];
    }
    void init(int _S,int _T){
        S=_S,T=_T,MaxFlow=0,init();
    }
    int bfs(){
        memset(dis,0,sizeof dis);
        head=tail=0;
        q[++tail]=T,dis[T]=1;
        while (head<tail)
            for (int x=q[++head],i=fst[x];i;i=e[i].nxt)
                if (!dis[e[i].y]&&e[i^1].cap){
                    if (e[i].y==T)
                        return 1;
                    dis[q[++tail]=e[i].y]=dis[x]+1;
                }
        return (bool)dis[S];
    }
    LL dfs(int x,LL Flow){
        if (x==T||!Flow)
            return Flow;
        LL now=Flow;
        for (int &i=cur[x];i;i=e[i].nxt){
            int y=e[i].y;
            if (dis[x]==dis[y]+1&&e[i].cap){
                LL d=dfs(y,min(now,e[i].cap));
                e[i].cap-=d,e[i^1].cap+=d,now-=d;
                if(now==0) break;
            }
        }
        return Flow-now;
    }
    LL GetMaxFlow(int _S,int _T){
        init(_S,_T);
        while (bfs()) init(),MaxFlow+=dfs(S,INF);
        return MaxFlow;
    }
}DC;

LL in[maxn], out[maxn], low[maxm];

int main(void){__stTIME();__IOPUT();

    int n, m;

    scii(n, m);

    DC.Clear(n+2);

    int ss = n+1, tt = n+2;

    for(int i=1; i<=m; i++){
        int u, v;
        LL upper;
        scii(u, v);
        scll(low[i], upper);
        out[u] += low[i];
        in[v] += low[i];
        DC.AddEdge(u, v, upper - low[i]);
    }

    LL FlowSum = 0;
    for(int i=1; i<=n; i++){
        if(in[i] - out[i] > 0) DC.AddEdge(ss, i, in[i] - out[i]), FlowSum += in[i] - out[i];
        else if(in[i] - out[i] < 0) DC.AddEdge(i, tt, out[i] - in[i]);
    }

    if(DC.GetMaxFlow(ss, tt) < FlowSum) puts("NO");
    else{
        puts("YES");
        for(int i=1; i<=m; i++) printf("%lld\n", low[i] + DC.e[i<<1 | 1].cap);
    }

__enTIME();return 0;}

void __stTIME()
{
    #if _TIME
        START = clock();
    #endif
}

void __enTIME()
{
    #if _TIME
        END = clock();
        cerr<<"execute time = "<<(double)(END-START)/CLOCKS_PER_SEC<<endl;
    #endif
}

void __IOPUT()
{
    #if _INPUT
        freopen("in.txt", "r", stdin);
    #endif
    #if _OUTPUT
        freopen("out.txt", "w", stdout);
    #endif
}

2、有源汇的上下界可行流

只要在无源汇的网络流基础上添加多一条边即可

添加从汇到源的一条边、上界为 INF、下界为 0

其余操作和无源汇的操作一样

3、有源汇的上下界最大流

上述可行流算法跑出来的并不一定是最大流

方法就是先跑一遍有源汇的上下界可行流

如果可行流跑出来的结果为可行则

保持这个网络图不要变

再跑一次从源到汇的最大流即为答案

LOJ 116 有源汇的上下界最大流模板题

#include<bits/stdc++.h>
#define LL long long
#define ULL unsigned long long

#define scl(i) scanf("%lld", &i)
#define scll(i, j) scanf("%lld %lld", &i, &j)
#define sclll(i, j, k) scanf("%lld %lld %lld", &i, &j, &k)
#define scllll(i, j, k, l) scanf("%lld %lld %lld %lld", &i, &j, &k, &l)

#define scs(i) scanf("%s", i)
#define sci(i) scanf("%d", &i)
#define scd(i) scanf("%lf", &i)
#define scIl(i) scanf("%I64d", &i)
#define scii(i, j) scanf("%d %d", &i, &j)
#define scdd(i, j) scanf("%lf %lf", &i, &j)
#define scIll(i, j) scanf("%I64d %I64d", &i, &j)
#define sciii(i, j, k) scanf("%d %d %d", &i, &j, &k)
#define scddd(i, j, k) scanf("%lf %lf %lf", &i, &j, &k)
#define scIlll(i, j, k) scanf("%I64d %I64d %I64d", &i, &j, &k)
#define sciiii(i, j, k, l) scanf("%d %d %d %d", &i, &j, &k, &l)
#define scdddd(i, j, k, l) scanf("%lf %lf %lf %lf", &i, &j, &k, &l)
#define scIllll(i, j, k, l) scanf("%I64d %I64d %I64d %I64d", &i, &j, &k, &l)

#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1
#define lowbit(i) (i & (-i))
#define mem(i, j) memset(i, j, sizeof(i))

#define fir first
#define sec second
#define VI vector<int>
#define ins(i) insert(i)
#define pb(i) push_back(i)
#define pii pair<int, int>
#define VL vector<long long>
#define mk(i, j) make_pair(i, j)
#define all(i) i.begin(), i.end()
#define pll pair<long long, long long>

#define _TIME 0
#define _INPUT 0
#define _OUTPUT 0
clock_t START, END;
void __stTIME();
void __enTIME();
void __IOPUT();
using namespace std;

const int maxn = 2000;
const int maxm = (10405) << 1;
const LL INF=0x7fffffff;

struct Edge{
    int x,y,nxt;
    LL cap;
    Edge(){}
    Edge(int a,int b,LL c,LL d)
    { x=a,y=b,cap=c,nxt=d; }
};

struct Dinic{
    static const int N=maxn, M=maxm;
    Edge e[M];
    int n,S,T,fst[N],cur[N],EdgeCnt;
    int q[N],dis[N],head,tail;
    LL MaxFlow;

    void Clear(int _n){
        n=_n,EdgeCnt=1;
        memset(fst,0,sizeof fst);
    }
    void AddEdge(int a,int b,LL c){
        e[++EdgeCnt]=Edge(a,b,c,fst[a]),fst[a]=EdgeCnt;
        e[++EdgeCnt]=Edge(b,a,0,fst[b]),fst[b]=EdgeCnt;
    }
    void init(){
        for (int i=1;i<=n;i++)
            cur[i]=fst[i];
    }
    void init(int _S,int _T){
        S=_S,T=_T,MaxFlow=0,init();
    }
    int bfs(){
        memset(dis,0,sizeof dis);
        head=tail=0;
        q[++tail]=T,dis[T]=1;
        while (head<tail)
            for (int x=q[++head],i=fst[x];i;i=e[i].nxt)
                if (!dis[e[i].y]&&e[i^1].cap){
                    if (e[i].y==T)
                        return 1;
                    dis[q[++tail]=e[i].y]=dis[x]+1;
                }
        return (bool)dis[S];
    }
    LL dfs(int x,LL Flow){
        if (x==T||!Flow)
            return Flow;
        LL now=Flow;
        for (int &i=cur[x];i;i=e[i].nxt){
            int y=e[i].y;
            if (dis[x]==dis[y]+1&&e[i].cap){
                LL d=dfs(y,min(now,e[i].cap));
                e[i].cap-=d,e[i^1].cap+=d,now-=d;
                if(now==0) break;
            }
        }
        return Flow-now;
    }
    LL GetMaxFlow(int _S,int _T){
        init(_S,_T);
        while (bfs()) init(),MaxFlow+=dfs(S,INF);
        return MaxFlow;
    }
}DC;

LL in[maxn], out[maxn], low[maxm];

int main(void){__stTIME();__IOPUT();

    int n, m, s, t;

    sciiii(n, m, s, t);

    DC.Clear(n+2);

    int ss = n+1, tt = n+2;

    for(int i=1; i<=m; i++){
        int u, v;
        LL upper;
        scii(u, v);
        scll(low[i], upper);
        out[u] += low[i];
        in[v] += low[i];
        DC.AddEdge(u, v, upper - low[i]);
    }DC.AddEdge(t, s, INF);

    LL FlowSum = 0;
    for(int i=1; i<=n; i++){
        if(in[i] - out[i] > 0) DC.AddEdge(ss, i, in[i] - out[i]), FlowSum += in[i] - out[i];
        else if(in[i] - out[i] < 0) DC.AddEdge(i, tt, out[i] - in[i]);
    }

    if(DC.GetMaxFlow(ss, tt) < FlowSum) puts("please go home to sleep");
    else printf("%lld\n", DC.GetMaxFlow(s, t));

__enTIME();return 0;}

void __stTIME()
{
    #if _TIME
        START = clock();
    #endif
}

void __enTIME()
{
    #if _TIME
        END = clock();
        cerr<<"execute time = "<<(double)(END-START)/CLOCKS_PER_SEC<<endl;
    #endif
}

void __IOPUT()
{
    #if _INPUT
        freopen("in.txt", "r", stdin);
    #endif
    #if _OUTPUT
        freopen("out.txt", "w", stdout);
    #endif
}

4、有源汇的上下借最小流

跑源汇的上下界可行流一次记为 F1

然后添加汇到源的一条边、上界为 INF、下界为 0

添加边后再跑一次上下界可行流一次记为 F2

若 F1 + F2 < ( 超级源点 ss 所有出边的流量之和 )

即满流的情况、则说明可行

最小流就是刚刚添加的从汇到源的那条边的流量

( 不过有点慢、要快的可以上 LOJ 提交记录里面找找快速的代码是如何实现的 )

LOJ 117 有源汇的上下界最小流模板

#include<bits/stdc++.h>
#define LL long long
#define ULL unsigned long long

#define scl(i) scanf("%lld", &i)
#define scll(i, j) scanf("%lld %lld", &i, &j)
#define sclll(i, j, k) scanf("%lld %lld %lld", &i, &j, &k)
#define scllll(i, j, k, l) scanf("%lld %lld %lld %lld", &i, &j, &k, &l)

#define scs(i) scanf("%s", i)
#define sci(i) scanf("%d", &i)
#define scd(i) scanf("%lf", &i)
#define scIl(i) scanf("%I64d", &i)
#define scii(i, j) scanf("%d %d", &i, &j)
#define scdd(i, j) scanf("%lf %lf", &i, &j)
#define scIll(i, j) scanf("%I64d %I64d", &i, &j)
#define sciii(i, j, k) scanf("%d %d %d", &i, &j, &k)
#define scddd(i, j, k) scanf("%lf %lf %lf", &i, &j, &k)
#define scIlll(i, j, k) scanf("%I64d %I64d %I64d", &i, &j, &k)
#define sciiii(i, j, k, l) scanf("%d %d %d %d", &i, &j, &k, &l)
#define scdddd(i, j, k, l) scanf("%lf %lf %lf %lf", &i, &j, &k, &l)
#define scIllll(i, j, k, l) scanf("%I64d %I64d %I64d %I64d", &i, &j, &k, &l)

#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1
#define lowbit(i) (i & (-i))
#define mem(i, j) memset(i, j, sizeof(i))

#define fir first
#define sec second
#define VI vector<int>
#define ins(i) insert(i)
#define pb(i) push_back(i)
#define pii pair<int, int>
#define VL vector<long long>
#define mk(i, j) make_pair(i, j)
#define all(i) i.begin(), i.end()
#define pll pair<long long, long long>

#define _TIME 0
#define _INPUT 0
#define _OUTPUT 0
clock_t START, END;
void __stTIME();
void __enTIME();
void __IOPUT();
using namespace std;

const int maxn = 55000 + 10;
const int maxm = (225003 + 1000)<<1;
const LL INF=0x7fffffff;

struct Edge{
    int x,y,nxt;
    LL cap;
    Edge(){}
    Edge(int a,int b,LL c,LL d)
    { x=a,y=b,cap=c,nxt=d; }
};

struct Dinic{
    static const int N=maxn, M=maxm;
    Edge e[M];
    int n,S,T,fst[N],cur[N],EdgeCnt;
    int q[N],dis[N],head,tail;
    LL MaxFlow;

    void Clear(int _n){
        n=_n,EdgeCnt=1;
        memset(fst,0,sizeof fst);
    }
    void AddEdge(int a,int b,LL c){
        e[++EdgeCnt]=Edge(a,b,c,fst[a]),fst[a]=EdgeCnt;
        e[++EdgeCnt]=Edge(b,a,0,fst[b]),fst[b]=EdgeCnt;
    }
    void init(){
        for (int i=1;i<=n;i++)
            cur[i]=fst[i];
    }
    void init(int _S,int _T){
        S=_S,T=_T,MaxFlow=0,init();
    }
    int bfs(){
        memset(dis,0,sizeof dis);
        head=tail=0;
        q[++tail]=T,dis[T]=1;
        while (head<tail)
            for (int x=q[++head],i=fst[x];i;i=e[i].nxt)
                if (!dis[e[i].y]&&e[i^1].cap){
                    if (e[i].y==T)
                        return 1;
                    dis[q[++tail]=e[i].y]=dis[x]+1;
                }
        return (bool)dis[S];
    }
    LL dfs(int x,LL Flow){
        if (x==T||!Flow)
            return Flow;
        LL now=Flow;
        for (int &i=cur[x];i;i=e[i].nxt){
            int y=e[i].y;
            if (dis[x]==dis[y]+1&&e[i].cap){
                LL d=dfs(y,min(now,e[i].cap));
                e[i].cap-=d,e[i^1].cap+=d,now-=d;
                if(now==0) break;
            }
        }
        return Flow-now;
    }
    LL GetMaxFlow(int _S,int _T){
        init(_S,_T);
        while (bfs()) init(),MaxFlow+=dfs(S,INF);
        return MaxFlow;
    }
}DC;

LL in[maxn], out[maxn], low[maxm];

int main(void){__stTIME();__IOPUT();

    int n, m, s, t;

    sciiii(n, m, s, t);

    DC.Clear(n+2);

    int ss = n+1, tt = n+2;

    for(int i=1; i<=m; i++){
        int u, v;
        LL upper;
        scii(u, v);
        scll(low[i], upper);
        out[u] += low[i];
        in[v] += low[i];
        DC.AddEdge(u, v, upper - low[i]);
    }

    LL FlowSum = 0;
    for(int i=1; i<=n; i++){
        if(in[i] - out[i] > 0) DC.AddEdge(ss, i, in[i] - out[i]), FlowSum += in[i] - out[i];
        else if(in[i] - out[i] < 0) DC.AddEdge(i, tt, out[i] - in[i]);
    }

    LL F1 = DC.GetMaxFlow(ss, tt);
    int id = (DC.EdgeCnt + 2)>>1;
    DC.AddEdge(t, s, INF);
    LL F2 = DC.GetMaxFlow(ss, tt);

    if(F1+F2 < FlowSum) puts("please go home to sleep");
    else printf("%lld\n", DC.e[id << 1 | 1].cap);

__enTIME();return 0;}

void __stTIME()
{
    #if _TIME
        START = clock();
    #endif
}

void __enTIME()
{
    #if _TIME
        END = clock();
        cerr<<"execute time = "<<(double)(END-START)/CLOCKS_PER_SEC<<endl;
    #endif
}

void __IOPUT()
{
    #if _INPUT
        freopen("in.txt", "r", stdin);
    #endif
    #if _OUTPUT
        freopen("out.txt", "w", stdout);
    #endif
}

5、有上下界的费用流

不好意思、不会......

原文地址：https://www.cnblogs.com/Rubbishes/p/9648323.html

时间： 2024-10-31 12:13:40

上下界的网络流模板的相关文章

BZOJ 2406 二分+有上下界的网络流判定

思路: 求出每行的和 sum_row 每列的和 sum_line 二分最后的答案mid S->i 流量[sum_row[i]-mid,sum_row[i]+mid] i->n+j 流量[L,R] n+j->T 流量 [sum_line[i]-mid,sum_line[i]+mid] 套用有上下界的网络流判一下就好了.. 这是道有上下界网络流的裸题 //By SiriusRen #include <queue> #include <cstdio> #inc

有上下界的网络流2-有源汇带上下界网络流ZOJ3229

ZOJ3229题目大意:一个屌丝给m个女神拍照,计划拍照n天,每一天屌丝可以和C个女神拍照,每天拍照数不能超过D张,而且给每个女神i拍照有数量限制[Li,Ri],对于每个女神n天的拍照总和不能少于Gi,如果有解求屌丝最多能拍多少张照,并求每天给对应女神拍多少张照:否则输出-1. 解题思路: 1.增设一源点st,汇点sd,st到第i天连一条上界为Di下界为0的边,每个女神到汇点连一条下界为Gi上界为正无穷的边,对于每一天,当天到第i个女孩连一条[Li,Ri]的边. 2.

有上下界的网络流1-无源汇带上下界网络流SGU194

今天开始啃网络流了.对于求解无源汇带上下界的网络流,我们可以这样建图:建图模型: 以前写的最大流默认的下界为0,而这里的下界却不为0,所以我们要进行再构造让每条边的下界为0,这样做是为了方便处理.对于每根管子有一个上界容量up和一个下界容量low,我们让这根管子的容量下界变为0,上界为up-low.可是这样做了的话流量就不守恒了,为了再次满足流量守恒,即每个节点"入流=出流",我们增设一个超级源点st和一个超级终点sd.我们开设一个数组du[]来记录每个节点的流量情况.

poj_2396 有上下界的网络流

题目大意一个mxn的矩阵,给出矩阵中每一行的和sh[1,2...m]以及每一列的数字的和目sv[1,2...n],以及矩阵中的一些元素的范围限制,比如a[1][2] > 1, a[2][3] < 4, a[3][3] = 10等等,且要求矩阵中的每个元素值非负.求出,是否存在满足所有给出的限制条件的矩阵,若存在输出. 题目分析这么多限制条件..开始只能想到暴力解法+剪枝.这他妈得需要多大的脑洞才能无中生有的想到网络流解法? 不过,给出网络流的想法之后发现采用网络流解法确实很合理,很简单(唯

ZOJ 2314 Reactor Cooling 带上下界的网络流

题目链接:http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=1314 题意: 给n个点,及m根pipe,每根pipe用来流躺液体的,单向的,每时每刻每根pipe流进来的物质要等于流出去的物质,要使得m条pipe组成一个循环体,里面流躺物质. 并且满足每根pipe一定的流量限制,范围为[Li,Ri].即要满足每时刻流进来的不能超过Ri(最大流问题),同时最小不能低于Li. 求的是最大流. 很久之前就看了带上下界的网络流,一直没看懂

【网络流补全计划】Part.Ⅲ有上下界的网络流

本来心情就非常糟糕调月下毛景树把我最后一点写代码的心情调没了放弃开始补全网络流. 之前学了普通最大流,那么现在开始补有上下界的网络流. 在普通最大流中,网络里的每一条边都只有流量的上界即边的容量,而引入上下界网络流之后,每个边不但有一个容量,还有一个流量下界. 我们令B(u,v)表示边(u,v)的下界.于是我们可以有表达式: B(u,v)≤f(u,v)≤C(u,v) 有这个式子可以得到 0≤f(u,v)≤C(u,v)?B(u,v) 至此,我们可以将有上下界的网络流分为几种问题来对待,接下来就

SGU 194. Reactor Cooling(无源汇有上下界的网络流)

时间限制:0.5s 空间限制:6M 题意: 显然就是求一个无源汇有上下界的网络流的可行流的问题 Solution: 没什么好说的,直接判定可行流,输出就好了 code /* 无汇源有上下界的网络流 */ #include <iostream> #include <cstring> #define ms(a,b) memset(a,b,sizeof a) using namespace std; const int MAXN = 209; struct node { int u, v

ZOJ 2314 有上下界的网络流

点击打开链接题意:给定m条边和n个节点,每条边最少的流量和最多的流量,保证每个节点的出入流量和相等,问可以形成吗,可以则输出每条边的流量思路:一道有上下界的网络流,因为有下界,说明我们每条边必须跑大于等于下界的流量,那我们可以转化一下,将下界设为必要边,也就是我们肯定会跑的边,而且这道题是没有源点和汇点的,所以我们要加这两个点,而对于一条边,a,b,low,high,我们a->b连的流量为high-low,a->T为low,S->b为low,跑最大流,如果满流则方案成功,找边的流量输

关于流量有上下界的网络流问题的求解

之前涉及到的网络流问题,每条弧的容量下限都是0,上限都是C.而在流量有上下界的网络流问题中,每条弧有一个流量下界low,还有一个上界up. 对于这样的问题,一般都三类: 1.没有源点和汇点的有上下界的网络最大流问题 2.有源点和汇点的有上下界的网络最大流问题 3.有源点和汇点的有上下界的网络最小流问题第一类问题: (没有源点和汇点的有上下界的网络最大流问题) [1]我们需要构造一个伴随网络,首先建立一个附加源点SS和一个附加汇点TT: [2]对于原网络中的每一个顶点Vi,在伴随网络中加一条新的