Dinic笔记

算法思想

Dinic相对于EK算法，更注重点的使用，Dinic算法首先BFS搜索将图进行分层，然后DFS沿着层次+1且$cap>flow$的方向寻找增广路，回溯时增流，

算法步骤

1. BFS残余网络，分层
2. 在层次图DFS，DFS沿着层次+1且$cap>flow$的方向找增广路，回溯增流
3. 重复步骤，直到不存在增广路

在DFS过程中，设搜索的当前节点为$i$，当到达$i$时，有一个预值$flow$作为$i$可增流的总值，也就是说，尽量使所有$i$的深层邻接点凑出这个$flow$，深层邻接点的增流被汇总到$i$，有些类似于累和，具体可见代码

Dinic执行时每次要重新分层，从源点到汇点的层次严格升序，设带权有向图中有$V$个点，最多就有$V$层，所以最多重新分层$V$次，设每次遍历的边数为$E(E\le 边总数)$，则最后的时间复杂度为$O(V^{2}E)$

代码实现

bool BFS(int s,int t) {
   
   //分层
    memset(d,0,sizeof(d));
    queue<int>q;
    q.push(s);
    d[s]=1;
    while(!q.empty()) {
   
   
        int u=q.front();
        q.pop();
        for(int i=head[u]; ~i; i=e[i].next) {
   
   
            int v=e[i].to;
            if(!d[v]&&e[i].cap>e[i].flow) {
   
   //如果可以增流
                d[v]=d[u]+1;
                q.push(v);
                if(v==t)return 1;
            }
        }
    }
    return 0;
}
int DFS(int u,int flow,int t) {
   
   
    if(u==t)return flow;
    int res=flow;//res存储当前节点的可增流值
    for(int i=head[u]; ~i&&res; i=e[i].next) {
   
   //遍历满足条件的邻边并增流
        int v=e[i].to;
        if(d[v]==d[u]+1&&e[i].cap>e[i].flow) {
   
   
            int k=DFS(v,min(res,e[i].cap-e[i].flow),t);//获得最小的回溯流
            if(!k){
   
   d[v]=0;continue;}
            e[i].flow+=k;//获得最小的回溯流后增流
            e[i^1].flow-=k;
            res-=k;//可增流值减少，因为已经有邻边增流
        }
    }
    return flow-res;//返回实际的总增流值
}
int Dinic(int s,int t) {
   
   
    int ans=0;//存储最大流
    while(BFS(s,t))ans+=DFS(s,inf,t);
    return ans;
}

结果输出

对于Dinic算法来说，最后一次的循环其实没有进行增流，它只是确定了没有不能再继续增流了，那么所需要的最大流中的所有节点一定被分层了，换言之，如果要输出答案，只需要找到有分层的点即可

当前弧优化

每次增广了一条路之后，由于是最大流，所以这条路必然没有了增广的必要，也没有多余的流量可增广，那么每次扫描的时候可以跳过这些无法增广的边，因此可以记录已经增广到哪条边了，下一次如果碰到同样的节点则直接从这条边开始增广，具体如图，对于节点2，如果2,3和2,4已经增流过了，其实之后的扫描就没有必要再访问了，这个时候如果开一个数组记录对于节点2当前访问的哪条边，这样的话就能减少不必要的扫描

代码

bool BFS(int s,int t) {
   
   //分层
    memset(d,0,sizeof(d));
    for(int i=0; i<=n+1; i++)//复制每个点的head，一定一定要注意节点的个数
        cur[i]=head[i];
    queue<int>q;
    q.push(s);
    d[s]=1;
    while(!q.empty()) {
   
   
        int u=q.front();
        q.pop();
        for(int i=head[u]; ~i; i=e[i].next) {
   
   
            int v=e[i].to;
            if(!d[v]&&e[i].cap>e[i].flow) {
   
   //如果可以增流
                d[v]=d[u]+1;
                q.push(v);
                if(v==t)return 1;
            }
        }
    }
    return 0;
}
int DFS(int u,int flow,int t) {
   
   
    if(u==t)return flow;
    int res=flow;//res存储当前节点的可增流值
    for(int i=cur[u]; ~i&&res; i=e[i].next) {
   
   //遍历满足条件的邻边并增流
        cur[u]=i;//当前弧