网络流总结

上下界网络流

上下界可行流

考虑把每条边必须经过的流量拆出来，那么就变成了某些边必须满流，求一组可行流。我们把必须满流的边拉出来，假想一个源汇 s,t，每条边起点连向 s，t 连向终点，跑 s 到 t 的最大流，若拉出来的边满流就找到了一组可行流。如果本来就有源汇，那么从 t 向 s 连流量正无穷的边，就转成无源汇网络流了。

上下界最大流

先求出一个可行流，把连向超级源汇的边删掉，再从 s 到 t 求残余网络最大流。

上下界最小流

拆满流边后，先不加 t 到 s 流量正无穷的边，跑出一个最大流，再加上 t 到 s 的边跑最大流，t 到 s 这条边的流量就是最小流。感性理解一下，加 t 到 s 边之前跑最大流会尽可能填满环流。

例题：luogu清理雪道

杂题

1

ZJOI2011 最小割（最小割树）
每次随便选择两个点，用边权为他们之间的最小割的边把他们连起来，再把点集按照最小割的划分分成两个部分，每个部分递归进行。这样会形成一棵树的结构，两个点的最小割就是树上两点间的最小边权。这道题是模板。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<cmath>
#define ll long long
using namespace std;
struct edge{
    int to,next,pre,flow;
}ed[6010];
const int inf=2e9;
int head[151],sz,deep[151],ans[151][151],p[151],q[151],node[151],S,T,vis[151],n,m;
inline void add_edge(int from,int to,int flow)
{
    ed[++sz].to=to;
    ed[sz].next=head[from];
    ed[sz].flow=flow;
    ed[sz].pre=flow;
    head[from]=sz;
}
inline int read()
{
    char c=getchar();int x=0,flag=1;
    while(!isdigit(c)) flag*=c=='-'?-1:1,c=getchar();
    while(isdigit(c)) x=x*10+c-'0',c=getchar();
    return x*flag;
}
bool bfs()
{
    memset(deep,0,sizeof(deep));
    queue <int> q;
    deep[S]=1;
    q.push(S);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        if(u==T) return true;
        for(int i=head[u];~i;i=ed[i].next)
        {
            int v=ed[i].to;
            if(ed[i].flow&&!deep[v])
            {
                deep[v]=deep[u]+1;
                q.push(v);
            }
        }
    }
    return false;
}
int dfs(int u,int come)
{
    if(u==T) return come;
    int rest=come;
    for(int i=head[u];~i;i=ed[i].next)
    {
        int v=ed[i].to;
        if(ed[i].flow&&deep[v]==deep[u]+1)
        {
            int new_flow=dfs(v,min(rest,ed[i].flow));
            ed[i].flow-=new_flow;
            ed[i^1].flow+=new_flow;
            rest-=new_flow;
            if(!rest) break;
        }
    }
    if(rest) deep[u]=-1;
    return come-rest;
}
int dinic()
{
    int ans=0;
    while(bfs()) ans+=dfs(S,inf);
    return ans;
}
void cut(int u)
{
    vis[u]=1;
    for(int i=head[u];~i;i=ed[i].next)
    {
        int v=ed[i].to;
        if(!vis[v]&&ed[i].flow) cut(v); 
    }
}
void solve(int l,int r)
{
    if(l==r)  return;
    for(int i=0;i<=sz;i++) ed[i].flow=ed[i].pre;
    memset(vis,0,sizeof(vis));
    S=node[l],T=node[r];
    int tmp=dinic();
    cut(node[l]);
    for(int i=1;i<=n;i++)
    {
        if(vis[i])
        {
            for(int j=1;j<=n;j++)
                if(!vis[j]) ans[i][j]=ans[j][i]=min(ans[i][j],tmp);
        }
    }
    int s=0,t=0;
    for(int i=l;i<=r;i++)
    {
        if(vis[node[i]]) p[++s]=node[i];
        else q[++t]=node[i];
    }
    int k=l-1;
    for(int i=1;i<=s;i++) node[++k]=p[i];
    for(int i=1;i<=t;i++) node[++k]=q[i];
    solve(l,l+s-1);
    solve(l+s,r);
}
void init()
{
    memset(head,-1,sizeof(head));
    memset(ans,0x7f,sizeof(ans));
    sz=-1;
}
int main()
{
    int T=read();
    while(T--)
    {
        init();
        n=read(),m=read();
        for(int i=1;i<=m;i++)
        {
            int u=read(),v=read(),w=read();
            add_edge(u,v,w);
            add_edge(v,u,w);
        }
        for(int i=1;i<=n;i++) node[i]=i;
        solve(1,n);
        int mm=read();
        for(int i=1;i<=mm;i++)
        {
            int x=read(),sum=0;
            for(int j=1;j<=n;j++)
                for(int k=j+1;k<=n;k++) if(ans[j][k]<=x) sum++;
            cout<<sum<<'\n';
        }
        cout<<'\n';
    }
    return 0;
}

2

AHOI2009 最小割
题意：判断每条边是否可能在最小割上，是否一定在最小割上。

先跑一个最大流，边 (u,v) 可能在最小割上的边的条件是：1.满流。2.残余网络中不存在 u 到 v 的路径。因为如果存在一个流量，那么这条边不会作为瓶颈。实现上第二个条件等价于判断残余网络上 u，v 是否在一个强连通分量里。

边 (u,v) 一定在最小割上的条件是：1.满流。2.残余网络中 s 能到达 u，v 能到达 t。只有这样 (u,v) 这条边才是不可代替的。实现上第二个条件等价于 u 和 s 在一个联通分量里，v 和 t 在一个联通分量里。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=40010,M=60010;
struct edge{
    int to,next,flow;
}ed[M<<1];
int n,m,S,T,sz=1,head[N],vis[N],tim,deep[N],q[N],low[N],dfn[N],st[N],top,inst[N],scc,bel[N],u[M],v[M],ind[M];
void add_edge(int from,int to,int flow)
{
    ed[++sz].to=to;
    ed[sz].flow=flow;
    ed[sz].next=head[from];
    head[from]=sz;
}
int read()
{
    int x=0;char flag='*',c=getchar();
    while(!isdigit(c)) flag=c,c=getchar();
    while(isdigit(c)) x=x*10+c-'0',c=getchar();
    return flag=='-'?-x:x;
}
bool bfs()
{
    int h=1,t=0;
    q[++t]=S;
    tim++;
    deep[S]=1;
    vis[S]=tim;
    while(t>=h)
    {
        int u=q[h++];
        for(int i=head[u];i;i=ed[i].next)
        {
            int v=ed[i].to;
            if(vis[v]!=tim&&ed[i].flow)
            {
                vis[v]=tim;
                deep[v]=deep[u]+1;
                if(v==T) return true;
                q[++t]=v;
            }
        }
    }
    return false;
}
int dfs(int u,int come)
{
    if(u==T) return come;
    int rest=come;
    for(int i=head[u];i;i=ed[i].next)
    {
        int v=ed[i].to;
        if(vis[v]==tim&&deep[v]==deep[u]+1&&ed[i].flow)
        {
            int nf=dfs(v,min(rest,ed[i].flow));
            ed[i].flow-=nf;
            ed[i^1].flow+=nf;
            rest-=nf;
            if(!rest) break;
        }
    }
    if(rest) deep[u]=-1;
    return come-rest;
}
void tarjan(int u)
{
    inst[u]=1;
    st[++top]=u;
    low[u]=dfn[u]=++tim;
    for(int i=head[u];i;i=ed[i].next)
    {
        int v=ed[i].to;
        if(!ed[i].flow) continue;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(inst[v]) low[u]=min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u])
    {
        scc++;
        while(1)
        {
            int now=st[top--];
            bel[now]=scc;
            inst[now]=0;
            if(now==u) break;
        }
    }
}
int main()
{
    n=read(),m=read(),S=read(),T=read();
    for(int i=1;i<=m;i++)
    {
        u[i]=read(),v[i]=read();int c=read();
        ind[i]=sz+1;
        add_edge(u[i],v[i],c);
        add_edge(v[i],u[i],0);
    }
    while(bfs()) dfs(S,1e9);
    tim=0;
    for(int i=1;i<=n;i++) if(!dfn[i]) tarjan(i);
    for(int i=1;i<=m;i++)
    {
        int x=u[i],y=v[i];
        if(ed[ind[i]].flow==0)
        {
            if(bel[x]==bel[y]) puts("0 0");
            else if(bel[S]==bel[x]&&bel[T]==bel[y]) puts("1 1");
            else puts("1 0");
        }
        else puts("0 0");
    }
    return 0;
}

一些定理

• 二分图上存在一组匹配覆盖某个点集 $A\cup B$（左边是A右边是B）当且仅当 A与右边的某个集合存在完美匹配（称为匹配1），并且 B 与左边的某个集合存在完美匹配（匹配2）。这样我们判定一个集合能否被覆盖的话两边就相对独立了。
  proof： 这显然是必要条件，接下来证明充分性：把匹配1中的边从左连向右，匹配2中的边从右连向左，那么我们会得到一些环和一堆链，其中环都是偶环，链的末端一定不再点集中。因此能够构造出一组边集覆盖所有点。

一些构造

• 构造最小点覆盖：跑出一组最大匹配，枚举左边的未匹配点，在残余网络上 bfs，到达的点打上标记。那么最小点覆盖就是左边的未标记点+右边的标记点。
  proof： 形式化地描述一下 bfs 的过程：如果当前在左边，把相邻的非匹配边的端点加入队列；如果当前在右边，沿着唯一的匹配边走回来（体现在 dinic 里就是反向弧）。我们先证明这样构造出的是一个点覆盖：对于一条非匹配边，如果左边是非匹配点，那么右边一定是匹配点，会在右边覆盖这条边；如果右边是非匹配点，那么这个点不可能被标记（如果被标记说明找到了一条增广路，与最大匹配矛盾），因此左边的点也不可能被标记，所以这条边会被左边的点覆盖。对于一条匹配边，要么两端都被标记，要么都不被标记。由于每条匹配边的恰好一个端点被标记，因此构造出的是最小点覆盖。
• 构造最长反链：求出一个最大独立集（最小点覆盖补集），入点出点都在最大独立集里的点即为所求。
  proof： 首先选出来的点一定是反链。最长反链=最小连覆盖=n-最大匹配=n-最小点覆盖，其中 n 是拆点前的点数。而且选出来的点数 >= n-最小点覆盖，因此构造出来的是最长反链。