模板：最大流

最新推荐文章于 2021-08-23 22:21:01 发布

原创最新推荐文章于 2021-08-23 22:21:01 发布 · 170 阅读

0 ·

CC 4.0 BY-SA版权

-----------图论------------ 专栏收录该内容

10 篇文章

订阅专栏

Edmonds-Karp：

先BFS从起点开始的路径中找最小的容量，找到这么一条路径，到 t 截止。

update更新残存容量和运输流量，加到max_flow里，

再继续BFS找路径，update，直到没有路径能到 t 了，返回0；

edmonds-karp返回最大流。

加反向边原因：http://blog.youkuaiyun.com/fobdddf/article/details/19611065

第一条路：1--2--4--6，如果没有反向边就堵了，而加上的话，第二条可以走，1--3--4--2--5--6，

相当于，第一条路后悔了，改走1--2--5--6，把4--6让给了第二条路。

const int maxn=500;
const int INF=2110000000;
int visited[maxn],pre[maxn],n,m;
int map[maxn][maxn];

void update_residual_network(int u,int flow){
    while(pre[u]!=-1){
        map[pre[u]][u]-=flow;
        map[u][pre[u]]+=flow;
        //printf(" %d-%d",u,pre[u]);
        u=pre[u];
    }
}
int find_path_bfs(int s,int t){
    memset(visited,0,sizeof(visited));
    memset(pre,-1,sizeof(pre));
    visited[s]=1;
    int min=INF;
    queue<int> q;
    q.push(s);
    while(!q.empty()){
        int cur=q.front();q.pop();
        if(cur==t)
            break;
        for(int  i = 1 ; i <= m ; i++ ){
            if( visited[i] == 0 && map[cur][i] != 0){
                q.push(i);
                min=(min<map[cur][i]?min:map[cur][i]) ;
                pre[i]=cur;
                visited[i]=1;
            }
        }
    }
    if(pre[t]==-1)
        return 0;
    return min;
}
int edmonds_karp(int s,int t){
    int new_flow=0;
    int max_flow=0;
    do{
        new_flow = find_path_bfs(s,t);
        update_residual_network(t,new_flow);
        max_flow += new_flow;
        //printf(" max=%d",new_flow);
    }while( new_flow != 0 );
    return max_flow;
}

Dinic：

这个Dinic是支持重边的，不会替代，会多加一条边进去。

struct Edge  
{  
    int from,to,cap,flow;  
    Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f){}  
};  
  
struct Dinic  
{  
    int n,m,s,t;//结点数，边数（包括反向弧），源点编号，汇点编号  
    vector<Edge>edges;//边表，dges[e]和dges[e^1]互为反向弧  
    vector<int>G[N];//邻接表，G[i][j]表示结点i的第j条边在e数组中的编号  
    bool vis[N]; //BFS的使用  
    int d[N]; //从起点到i的距离  
    int cur[N]; //当前弧下标  
  
    void addedge(int from,int to,int cap)  
    {  
        edges.push_back(Edge(from,to,cap,0));  
        edges.push_back(Edge(to,from,0,0));  
        int  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);  
        d[s]=0;  
        vis[s]=1;  
        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)//x表示当前结点，a表示目前为止的最小残量  
    {  
        if(x==t||a==0)return a;//a等于0时及时退出，此时相当于断路了  
        int flow=0,f;  
        for(int&i=cur[x];i<G[x].size();i++)//从上次考虑的弧开始，注意要使用引用，同时修改cur[x]  
        {  
            Edge&e=edges[G[x][i]];//e是一条边  
            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)break;//a等于0及时退出，当a!=0,说明当前节点还存在另一个曾广路分支。  
  
            }  
        }  
        return flow;  
    }  
  
    int Maxflow(int s,int t)//主过程  
    {  
        this->s=s,this->t=t;  
        int flow=0;  
        while(bfs())//不停地用bfs构造分层网络，然后用dfs沿着阻塞流增广  
        {  
            memset(cur,0,sizeof(cur));  
            flow+=dfs(s,INF);  
        }  
        return flow;  
    }  
  };

SAP：

const int MAXN = 100010;   //点的总数
const int MAXM = 400010;    //边的总数
const int INF = 1<<30;
int n,m,source,sink,G,S;
int mp1[55][55],mp2[55][55];

struct EDG{
    int to,next,cap,flow;
} edg[MAXM];
int eid,head[MAXN];
int gap[MAXN];  //每种距离(或可认为是高度)点的个数
int dis[MAXN];  //每个点到终点eNode 的最短距离
int cur[MAXN];  //cur[u] 表示从u点出发可流经 cur[u] 号边
int pre[MAXN];

void init(){
    eid=0;
    memset(head,-1,sizeof(head));
}
//有向边 三个参数，无向边4个参数
void AddEdge(int u,int v,int c,int rc=0){
    edg[eid].to=v; edg[eid].next=head[u];
    edg[eid].cap=c; edg[eid].flow=0; head[u]=eid++;

    edg[eid].to=u; edg[eid].next=head[v];
    edg[eid].cap=rc; edg[eid].flow=0; head[v]=eid++;
}
int maxFlow_sap(int sNode,int eNode, int n){//n是包括源点和汇点的总点个数，这个一定要注意
    memset(gap,0,sizeof(gap));
    memset(dis,0,sizeof(dis));
    memcpy(cur,head,sizeof(head));
    pre[sNode] = -1;
    gap[0]=n;
    int ans=0;  //最大流
    int u=sNode;
    while(dis[sNode]<n){   //判断从sNode点有没有流向下一个相邻的点
        if(u==eNode){   //找到一条可增流的路
            int Min=INF ;
            int inser;
            for(int i=pre[u]; i!=-1; i=pre[edg[i^1].to])    //从这条可增流的路找到最多可增的流量Min
            if(Min>edg[i].cap-edg[i].flow){
                Min=edg[i].cap-edg[i].flow;
                inser=i;
            }
            for(int i=pre[u]; i!=-1; i=pre[edg[i^1].to]){
                edg[i].flow+=Min;
                edg[i^1].flow-=Min;  //可回流的边的流量
            }
            ans+=Min;
            u=edg[inser^1].to;
            continue;
        }
        bool flag = false;  //判断能否从u点出发可往相邻点流
        int v;
        for(int i=cur[u]; i!=-1; i=edg[i].next){
            v=edg[i].to;
            if(edg[i].cap-edg[i].flow>0 && dis[u]==dis[v]+1){
                flag=true;
                cur[u]=pre[v]=i;
                break;
            }
        }
        if(flag){
            u=v;
            continue;
        }
        //如果上面没有找到一个可流的相邻点，则改变出发点u的距离（也可认为是高度）为相邻可流点的最小距离+1
        int Mind= n;
        for(int i=head[u]; i!=-1; i=edg[i].next)
        if(edg[i].cap-edg[i].flow>0 && Mind>dis[edg[i].to]){
            Mind=dis[edg[i].to];
            cur[u]=i;
        }
        gap[dis[u]]--;
        if(gap[dis[u]]==0) return ans;  //当dis[u]这种距离的点没有了，也就不可能从源点出发找到一条增广流路径
                                        //因为汇点到当前点的距离只有一种，那么从源点到汇点必然经过当前点，然而当前点又没能找到可流向的点，那么必然断流
        dis[u]=Mind+1;//如果找到一个可流的相邻点，则距离为相邻点距离+1，如果找不到，则为n+1
        gap[dis[u]]++;
        if(u!=sNode) u=edg[pre[u]^1].to;  //退一条边
    }
    return ans;
}