网络流-＞最大流-＞Dinic板子&&Dinic当前弧优化代码详解

又是贴板子的一天
贴贴

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e3+7;
const int inf=0x3f3f3f3f;
int cnt=0,n,m;
int s,t;
int head[maxn];
int dep[maxn];
struct edge{
    int to,cost,next;
}e[maxn*20];
void add(int u,int v,int w){
    e[cnt].to=v;
    e[cnt].cost=w;
    e[cnt].next=head[u];
    head[u]=cnt++;
}
bool bfs(){
    queue<int>Q;
    memset(dep,0,sizeof(dep));
    dep[s]=1;
    Q.push(s);
    while(!Q.empty()){
        int u=Q.front();
        Q.pop();
        for(int i=head[u];~i;i=e[i].next){
            int v=e[i].to,f=e[i].cost;
            if(!dep[v]&&f){
                dep[v]=dep[u]+1;
                Q.push(v);
            }
        }
    }
    return dep[t]!=0;
}
int dfs(int u,int flow){
    if(u==t)return flow;
    for(int i=head[u];~i;i=e[i].next){
        int v=e[i].to;
        int f=e[i].cost;
        if(dep[v]==dep[u]+1&&f){
            int df=dfs(v,min(f,flow));
            if(df){
                e[i].cost-=df;
                e[i^1].cost+=df;
                return df;
            }
        }
    }
    return 0;
}
void dinic(){
    int ans=0;
    while(bfs()){
        int delta;
        do{
            delta=dfs(s,inf);
            ans+=delta;
        }while(delta);
    }
    cout<<ans;
    return ;
}
int main(){
    memset(head,-1,sizeof(head));
    cin>>n>>m>>s>>t;
    for(int i=0,u,v,w;i<n;i++){
        cin>>u>>v>>w;
        add(u,v,w);
        add(v,u,0);
    }
    dinic();
    return 0;
}

Dinic当前弧优化（有的题容易卡朴素Dinic）

#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<iomanip>
#define endl '\n'
#define ms(a,num) memset(a,num,sizeof(a))
using namespace std;
typedef long long ll;
typedef pair<double,int> P;
const int maxn = 2e2 + 7;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;

//------------------------------变量

int n,m,s,t;//n个点,m条边,s为起点,t为终点
int dep[maxn],cur[maxn];//dep表示每个点的层数,cur表示当前弧优化的头指针数组
struct edge{//链式前向星建图
    int to,cost,next;
}e[maxn];
int cnt;
int head[maxn];

//------------------------------函数

void add(int u,int v,int w){//加边函数
    e[cnt].to=v;
    e[cnt].cost=w;
    e[cnt].next=head[u];
    head[u]=cnt++;
}
bool bfs(){
    queue<int>q;
    ms(dep,-1);//dep初始化为-1
    q.push(s);
    dep[s]=0;//源点层数记为0
    cur[s]=head[s];//cur初始化同head
    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(dep[v]<0&&e[i].cost){//如果v未被访问且残量为正
                dep[v]=dep[u]+1;//层数更新
                cur[v]=head[v];//更新cur
                if(v==t)return true;//bfs到t了说明存在增广路
                q.push(v);
            }
        }
    }
    return false;//未找到t说明不存在增广路了
}
int dfs(int u,int limit){//u是当前点,limit是u还可以分给后面点的最大流量
    if(u==t)return limit;//找到汇点返回本次找到的流量
    int flow=0;//flow是已经从u点分出去的流量，最初为0
    for(int i=cur[u];~i;i=e[i].next){//循环u的所有出边，此处用到的cur数组就是当前弧优化，访问所有还可以扩大流量的边
        cur[u]=i;//更新cur，循环到i说明u已经用到了i，前i-1条边已经被榨干了，下次直接就可以使用第i条边了
        int v=e[i].to;
        if(dep[v]==dep[u]+1&&e[i].cost){//如果v点是u的下一层，且残量为正，说明是一条增广路
            int minf=dfs(v,min(limit-flow,e[i].cost));//递归v点，给v点的流量是该边的容量和剩余容量中较小的那一个，minf是返回这条增广路上能增广的量
            e[i].cost-=minf;//更新残留网络
            e[i^1].cost+=minf;
            flow+=minf;//更新分出去的流量
            if(flow==limit)return flow;//当前弧优化的细节，如果分出去的流量flow和最大流量limit相等了，说明流量全分出去了，不可能再分了，直接返回
        }
    }
    return flow;//return分出去的最大流量flow
}
int Dinic(){
    int ans=0;
    while(bfs()){//当存在增广路时，bfs得到分层图
        ans+=dfs(s,inf);
    }
    return ans;
}

//------------------------------

int main(){
    cin>>n>>m>>s>>t;
    ms(head,-1);
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,0);
    }
    cout<<Dinic()<<endl;
    return 0;
}

网络流学习了一天了，也算是理解了为什么说网络流难在建模了。。。
养猪流模型：养猪流
题目大意：
N个人 M个猪圈，每个猪圈有x[i] 个猪，然后我们输入人的信息，每个人可以打开若干个猪圈 这个人想要购买B头猪，问这个模型可以卖出去多少头猪。
题解：
今天看了一上午，各种变量把我给绕晕了，问了学长才大概搞懂
我们可以标记一下最先打开某个猪圈的人的编号，由于第一个人买完猪后，后面的人想要再买肯定会受影响，也就是说买猪这个操作是具有后效性的，那么我们可以像这样想：上一个人将某个猪圈中的猪买完了，下一个来该猪圈的人只能在上一个人手中买猪了（巧妙的建边方法），于是我们让第一个打开某个猪圈的人与超级源点建立一条边，边容为当前猪圈内猪的个数，让每一个人与超级汇点建立一条边，边容为这个人想要购买的猪的个数X（因为每个人购买的猪不能超过X）。
两个人之间的边容初始化为无穷大，因为有汇点边容的限制，所以人与人之间的边容不需要限制。
AC代码：

#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<iomanip>
#define endl '\n'
#define ms(a,num) memset(a,num,sizeof(a))
using namespace std;
typedef long long ll;
typedef pair<double,int> P;
const int maxn = 2e3 + 7;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;

int n,m,s,t;
int a[maxn],vis[maxn];//a记录猪圈内猪的个数，vis为标记当前猪圈是谁在进行交易
int dep[maxn],cur[maxn];
int head[maxn];
int cnt;
struct edge{
    int to,cost,next;
}e[maxn];

void add(int u,int v,int w){
    e[cnt].to=v;
    e[cnt].cost=w;
    e[cnt].next=head[u];
    head[u]=cnt++;
}
bool bfs(){
    queue<int>q;
    ms(dep,-1);
    dep[s]=0;
    cur[s]=head[s];
    q.push(s);
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int i=head[u];~i;i=e[i].next){
            int v=e[i].to;
            int f=e[i].cost;
            if(dep[v]<0&&f){
                dep[v]=dep[u]+1;
                cur[v]=head[v];
                if(v==t)return true;
                q.push(v);
            }
        }
    }
    return false;
}
int dfs(int u,int limit){
    if(u==t)return limit;
    int flow=0;
    for(int i=cur[u];~i;i=e[i].next){
        cur[u]=i;
        int v=e[i].to;
        int f=e[i].cost;
        if(dep[v]==dep[u]+1&&f){
            int minf=dfs(v,min(limit-flow,f));
            e[i].cost-=minf;
            e[i^1].cost+=minf;
            flow+=minf;
            if(flow==limit)return flow;
        }
    }
    return flow;
}
int Dinic(){
    int ans=0;
    while(bfs()){
        ans+=dfs(s,inf);
    }
    return ans;
}
int main(){
    cin>>m>>n;
    ms(head,-1);
    ms(vis,0);
    cnt=0;
    for(int i=1;i<=m;i++)cin>>a[i];
    for(int i=1;i<=n;i++){
        int op,cost;
        cin>>op;
        for(int j=1;j<=op;j++){
            int pos;
            cin>>pos;
            if(!vis[pos]){//如果该猪圈还没有被打开过
                add(0,i,a[pos]);//与超级源点建立边
                add(i,0,0);//反向边
            }
            else{//如果当前猪圈已经被打开了
                add(vis[pos],i,inf);//与当前正在交易的人建立边
                add(i,vis[pos],0);//反向边
            }
            vis[pos]=i;//更新当前猪圈的使用者
        }
        cin>>cost;
        add(i,n+1,cost);//与超级汇点建立边
        add(n+1,i,0);//反向边
    }
    s=0;
    t=n+1;
    cout<<Dinic()<<endl;
    return 0;
}

未完待续