ACM网络流模板（更新ing...）

1、最大流

FF、EK、Dinic算法比较

Dinic算法

2、二分图匹配

匈牙利算法

3、最小费用流

SPFA算法求解

Dijkstra算法求解

1、最大流（ FF、EK、Dinic算法比较）

Ford-Fulkerson算法：通过dfs不断寻找增广路，复杂度O(V·E^2)，效率较低。
Edmonds-Karp算法：通过bfs不断寻找增广路，复杂度O(V·E^2)，效率比FF略好，但是还是较低。
Dinic算法：首先bfs预处理出层次图，然后在层次图上dfs进行增广，复杂度 O(V^2·E)，时间效率较好。

2、最大流（Dinic算法）
描述: Dinic算法总是寻找最短的增广路，并沿着它增广。与之相对，EK算法执行完一次bfs增广后，要重新从源点s开始寻找另一条增广路,而在Dinic算法中，只需一次bfs就可以实现多次增广，效率提高。
复杂度: O(V^2·E)

int V,E;
struct edge{ //用于表示边的结构体(终点，容量，反向边）
    int to,cap,rev;
    edge(int t,int c,int r):to(t),cap(c),rev(r){}
};
vector<edge>G[Max_v]; 
int level[Max_v];     //顶点到源点的距离标号
int iter[Max_v];      //当前弧，之前的边已经用过了

void add_edge(int from,int to,int cap){
    G[from].push_back(edge(to,cap,G[to].size()));
    G[to].push_back(edge(from,0,G[from].size()-1));
}

//通过BFS构造层次图
void bfs(int s){
    memset(level,-1,sizeof(level));
    queue<int>que;
    level[s]=0;
    que.push(s);
    while(!que.empty()){
        int u=que.front();que.pop();
        for(int i=0;i<G[u].size();i++){
            edge e=G[u][i];
            if(e.cap>0&&level[e.to]<0){
                level[e.to]=level[u]+1;
                que.push(e.to);
            }
        }
    }
}

//在层次图上通过dfs不断寻找增广路
int dfs(int u,int t,int f){
    if(u==t)return f;
    for(int &i=iter[u];i<G[u].size();i++){  //int &i=iter[u]当前弧优化
        edge &e=G[u][i];
        if(e.cap>0&&level[u]<level[e.to]){
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0){
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return -1;
}

int max_flow(int s,int t){
    int flow=0;
    while(true){
        bfs(s);
        if(level[t]<0)return flow;
        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,inf))>0){   //两层括号
            flow+=f;
        }
    }
}

3、二分图匹配（匈牙利算法）
描述: 思想为寻找增广路，在二分图匹配中，如果一条路径首尾是非匹配点，路径中除此之外都是匹配点，那么这条路径就是一条增广路。

int V; //二分图左侧顶点数
vector<int>G[Max_v];
int match[Max_v]; //记录妹子的男盆友
int used[Max_v];

void add_edge(int u,int v){
    G[u].push_back(v);
}

bool dfs(int u){
    used[u]=1;
    for(int i=0;i<G[u].size();i++){
        int v=G[u][i],w=match[v];
        if(w<0||!used[w]&&dfs(w)){
            match[v]=u; //记录妹子的男盆友
            return true;
        }
    }
    return false;
}

int max_match(){
    int ans=0;
    memset(match,-1,sizeof(match));
    for(int i=0;i<V;i++){
        memset(used,0,sizeof(used));
        if(dfs(i))ans++;
    }
    return ans;
}

4、最小费用流（SPFA算法求解）
描述: 在残余网络上总是沿着最短（费用）路增广。
复杂度: < O(F|V||E|)

int V;
struct edge{
    int to,cap,cost,rev;
    edge(int t,int c,int co,int r):to(t),cap(c),cost(co),rev(r){}
};
int dist[Max_v];
bool used[Max_v];
int prv[Max_v],pre[Max_v]; //最短路的前驱节点和对应的边
vector<edge>G[Max_v]; 

void add_edge(int from,int to,int cap,int cost){
    G[from].push_back(edge(to,cap,cost,G[to].size()));
    G[to].push_back(edge(from,0,-cost,G[from].size()-1));
}

int min_cost_flow(int s,int t,int f){
    int ans=0;
    while(f>0){
        //用spfa寻找最短（费用）路
        memset(dist,0x3f,sizeof(dist));
        memset(used,0,sizeof(used));
        queue<int>que;
        que.push(s);
        dist[s]=0;used[s]=1;
        while(!que.empty()){
            int u=que.front();que.pop();
            used[u]=0;
            for(int i=0;i<G[u].size();i++){
                edge &e=G[u][i];
                if(e.cap>0&&dist[e.to]>dist[u]+e.cost){
                    dist[e.to]=dist[u]+e.cost;
                    prv[e.to]=u;pre[e.to]=i;
                    if(!used[e.to]){
                        que.push(e.to);
                        used[e.to]=1;
                    }
                }
            }
        }
        if(dist[t]==inf)//找不到增广路了
            return -1; 
        //沿s到t的最短路尽量增广
        int d=f;
        for(int v=t;v!=s;v=prv[v]){
            d=min(d,G[prv[v]][pre[v]].cap);
        }
        f-=d;
        ans+=d*dist[t];
        for(int v=t;v!=s;v=prv[v]){
            edge &e=G[prv[v]][pre[v]];
            e.cap-=d;
            G[e.to][e.rev].cap+=d;
        }
    }
    return ans;
}

5、最小费用流（Dijkstra算法求解）
描述: 在残余网络上总是沿着最短（费用）路增广。引入势h(v)，取h(v)=s到v的最短距离，将边e=(u,v)的长度变为d’(e)=d(e)+h(u)-h(v)，使得对所有的e都有d’(e)>=0，就可用Dijkstra算法求解在d’中求解最短路。
复杂度: O(F|E|log|V|)

struct edge{
    int to,cap,cost,rev; //终点、容量、费用、反向边
    edge(int t,int c,int co,int r):to(t),cap(c),cost(co),rev(r){}
};
int V;
int h[Max_v];    //顶点的势
int dist[Max_v]; //考虑势之后的最短距离
int prv[Max_v],pre[Max_v]; //最短路的前驱节点和对应的边
vector<edge>G[Max_v];

void add_edge(int from,int to,int cap,int cost){
    G[from].push_back(edge(to,cap,cost,G[to].size()));
    G[to].push_back(edge(from,0,-cost,G[from].size()-1));
}

int min_cost_flow(int s,int t,int f){
    int ans=0;
    memset(h,0,sizeof(h));
    while(f>0){
        priority_queue<P,vector<P>,greater<P> >que;
        memset(dist,0x3f,sizeof(dist));
        dist[s]=0;
        que.push(P(0,s));
        while(!que.empty()){
            P p=que.top();que.pop();
            int u=p.second,d=p.first;
            if(d>dist[u])continue;
            for(int i=0;i<G[u].size();i++){
                edge &e=G[u][i];
                if(e.cap>0&&dist[e.to]>dist[u]+e.cost+h[u]-h[e.to]){
                    dist[e.to]=dist[u]+e.cost+h[u]-h[e.to];
                    prv[e.to]=u;
                    pre[e.to]=i;
                    que.push(P(dist[e.to],e.to));
                }
            }
        }
        if(dist[t]==inf) //找不到增广路了
            return -1;
        for(int v=0;v<V;v++)h[v]+=dist[v]; //更新h[v]
        //沿s到t的最短路尽量增广
        int d=f;
        for(int v=t;v!=s;v=prv[v])
            d=min(d,G[prv[v]][pre[v]].cap);
        f-=d;
        ans+=d*h[t];
        for(int v=t;v!=s;v=prv[v]){
            edge &e=G[prv[v]][pre[v]];
            e.cap-=d;
            G[v][e.rev].cap+=d;
        }
    }
    return ans;
}

ACM网络流模板（更新ing...）

猜你喜欢