网络流
基本
是图论中的一个分支。可以把它看做水流的流输。
一张有向图。
源点:S;
就是所有水流流出点
汇点:T;
就是最终水流流入点。
x->y 边有一个容量值c(x,y)。可以理解为水管的最大运输量。
也有一个流值 f(x,y)。可以理解为水管现在的水流量。
c(x,y)- f(x,y)为剩余流量。
f(x,y)满足三个点:
1.容量限制:f(x,y)<=c(x,y)
2.斜对称:f(x,y)=-f(y,x)
3.流量守恒:对于x点,流入的量的总和=流出的量总和。
算法进阶指南上将他描述为:在不超过容量限制的前提下,流从源点出发,经过各条边,流入汇点。
最大流
就是水网中使流量最大的流方法。
Edmonds—Karp算法
当有一条路径,所有边的剩余容量都大于0,就可以算作一条增广路。
EK不断BFS,建立动态的网络流图,找到增广路,直到再也无法找到增广路。这时候的流量总和就是最大流。
注意:由于斜对称性,每条边有一个反向边,初始剩余流量为0。在bfs处理过程中,将增广路的边减去流,将其反向边加上流。
其使用规模大约是10^3~10^4.
模板
#include<bits/stdc++.h>
using namespace std;
const int M=1e9+10;
int n,m,t=1,ans=0;
int inf[1010]={},pre[1010]={};
bool vis[1010]={};
struct edge
{
int y,next,v;
}a[1000010];
int linkk[1010]={};
void insert(int x,int y,int v)//t初始值为1,每条边xor 1 后就是其反向边。
{
a[++t].y=y;a[t].next=linkk[x];a[t].v=v;linkk[x]=t;
a[++t].y=x,a[t].next=linkk[y];a[t].v=0;linkk[y]=t;
}
void init()
{
scanf("%d%d",&n,&m);
int x,y,v;
for(int i=1;i<=n;++i)
{
scanf("%d%d%d",&x,&y,&v);
insert(x,y,v);
}
}
bool bfs()//可以spfa优化
{
queue<int> q;
memset(vis,0,sizeof(vis));
q.push(1);//加入源点
vis[1]=1;
inf[1]=M;
while (q.size())
{
int x=q.front();q.pop();
for(int i=linkk[x];i;i=a[i].next)
if (a[i].v)
{
int y=a[i].y;
if (vis[y]) continue;
inf[y]=min(inf[x],a[i].v);
pre[y]=i;q.push(y);vis[y]=1;
if (y==m) return 1;//搜到汇点。
}
}
return 0;
}
void updata()
{
int x=m,c=inf[m];
while (x!=1)//回溯
{
int i=pre[x];
a[i].v-=c;
a[i^1].v+=c;//流两边处理
x=a[i^1].y;
}
ans+=c;
}
void work()
{
while (bfs()) updata();
printf("%d",ans);
}
int main()
{
init();
work();
return 0;
}
dinic算法
dinic算法还是更常用一点,同时也相对更难敲一点。
分层图
在bfs时,每个点有一个深度顺序,将相同顺序的点放在同一层中
dinic在bfs时将整张图按照深度建立一张分层图,在这张分层图上dfs,求增广路,并且回溯时更新剩余容量。
差不多可以处理10^4~10^5这么大的网络
模板
#include<bits/stdc++.h>
using namespace std;
const int M=1e9;
int m,n,t=1,ans=0,head,tail;
struct edge
{
int y,next,v;
}a[1000010];
int linkk[1010]={},dep[1010]={},q[2010]={};
inline int read()
{
int num=0;char c=getchar();
for(;c<'0'||c>'9';c=getchar());
for(;c<='9'&&c>='0';c=getchar()) num=(num<<1)+(num<<3)+c-48;
return num;
}
void insert(int x,int y,int v)
{
a[++t].y=y;a[t].v=v;a[t].next=linkk[x];linkk[x]=t;
a[++t].y=x;a[t].v=0;a[t].next=linkk[y];linkk[y]=t;
return ;//建立双向流量边
}
void init()
{
n=read();
m=read();
int x,y,v;
for(int i=1;i<=n;++i)
{
x=read();y=read();v=read();
insert(x,y,v);
}
return ;
}
bool bfs()
{
memset(dep,0,sizeof(dep));
head=0;tail=1;
q[1]=1;
dep[1]=1;
while (++head<=tail)
{
int x=q[head];
for(int i=linkk[x];i;i=a[i].next)
if (a[i].v&&!dep[a[i].y])//无流量边被忽略,已处理点不处理。
{
int y=a[i].y;
dep[y]=dep[x]+1;
q[++tail]=y;
if (y==m) return 1;
}
}
return 0;
}
int dinic(int x,int flow)
{
if (x==m) return flow;
int rest=flow,k;
for(int i=linkk[x];i&&rest;i=a[i].next)
if (a[i].v)
{
int y=a[i].y;
if (dep[y]!=dep[x]+1) continue;
k=dinic(y,min(rest,a[i].v));
if (!k) dep[y]=0;//这条边上找不到增广路了,就删除这个点,相当于一个剪枝。
rest-=k;
a[i].v-=k;
a[i^1].v+=k;
}
return flow-rest;
}
void work()
{
int flow;
while (bfs())//每次建立新图。
while (flow=dinic(1,M)) ans+=flow;//寻找增广路。
return ;
}
int main()
{
init();
work();
printf("%d",ans);
return 0;
}
费用流
每条边给另一个值单位费用w(x,y)。
求在最大流前提下的最小费用和。
EK
EK算法求最大流的基础上,用spfa求一个费用最短路。
模板
#include<bits/stdc++.h>
using namespace std;
const int MM=1e9;
int n,m,s,t,tot=1,ansf,answ;
int q[200010]={},pre[5010]={},dis[5010]={},inf[200010]={};
bool vis[5010]={};
struct edge
{
int y,next,v,w;
}a[100010];
int linkk[5010]={};
void insert(int x,int y,int v,int w)
{
a[++tot].y=y;a[tot].v=v; a[tot].w=w;
a[tot].next=linkk[x]; linkk[x]=tot;
a[++tot].y=x;a[tot].v=0;a[tot].w=-w;
a[tot].next=linkk[y]; linkk[y]=tot;
return ;
}
void init()
{
scanf("%d%d%d%d",&n,&m,&s,&t);
int x,y,v,w;
for(int i=1;i<=m;++i)
{
scanf("%d%d%d%d",&x,&y,&v,&w);
insert(x,y,v,w);
}
return ;
}
bool spfa()
{
memset(vis,0,sizeof(vis));
memset(dis,10,sizeof(dis));
q[1]=s;vis[s]=1;
dis[s]=0;inf[s]=MM;
int head=0,tail=1;
while (++head<=tail)
{
int x=q[head];
for(int i=linkk[x];i;i=a[i].next)
{
if (!a[i].v) continue;
int y=a[i].y;
if (dis[y]>dis[x]+a[i].w)
{
dis[y]=dis[x]+a[i].w;
inf[y]=min(inf[x],a[i].v);
pre[y]=i;
if (!vis[y])
{
vis[y]=1;
q[++tail]=y;
}
}
}
vis[x]=0;
}
return (dis[t]!=dis[n+1]);
}
void updata()
{
int x=t;
while (x!=s)
{
int i=pre[x];
a[i].v-=inf[t];
a[i^1].v+=inf[t];
x=a[i^1].y;
}
ansf+=inf[t];
answ+=dis[t]*inf[t];
}
int main()
{
init();
while (spfa())
updata();
printf("%d %d",ansf,answ);
return 0;
}
最小割
在一张网络中,割掉若干条边,使网络不连通(源点无法到达汇点),而割掉边的所有方案中,边权值和最小的方案就是最小割。
性质
1.割>=最大流
就是说割的边容量之和是大于等于最大流的。
如果有小于等于最大流的割,那么说明网络中仍有增广路,而最大流满足网络中没有增广路,两者相矛盾
2.最小割=最大流
网络最大流量等于最小割的流量和。
根据性质1,方案最优的最小割是等于最大流的。
求最小割每条边
求出最大流之后,在剩余容量网络中跑bfs。标记可以到达的点。枚举边(x,y)。x被标记而y不被标记的边为割边。
点边转化
当要求割去点的时候,可以通过把点拆为·x,x’(x’即在x+n位置),然后将x与x’连有向边x->x’。(容量为点权)
对于每条无向边,连两条有向边x’->y,y’->x。(容量为无穷大)
然后求最小割(最大流)。
求出答案。
模板
背景
FJ有个农场,其中有n块土地,由m条边连起来。FJ的养牛场在土地1,在土地n有个新开张的雪糕店。Bessie经常偷偷溜到雪糕店,当Bessie去的时候,FJ就要跟上她。但是Bessie很聪明,她在从雪糕店返回时不会经过去雪糕店时经过的农场,因此FJ总是抓不住Bessie。 为了防止Bessie生病,FJ决定把一些诚实的狗放在一些土地(1和n除外)上,使Bessie无法在满足每块土地最多只经过一次的条件的情况下,从养牛场溜到雪糕店然后又溜回养牛场。 求出FJ最少要放多少只狗。数据保证1和n间没有直接的连边。
解析
由于可以到达终点,但只能留一条路径,所以求了最小割以后减去1,就是答案,但不要忘了特判0。
code
#include<bits/stdc++.h>
using namespace std;
const int MM=2e9;
int n,m,s,t,tot=1,ans=0;
struct edge
{
int y,next,v;
}a[100010];
int linkk[2010]={},inf[2010]={},pre[100010]={},q[1000010]={};
bool vis[2010]={};
void insert(int x,int y,int v)
{
a[++tot].y=y;a[tot].next=linkk[x];
linkk[x]=tot;a[tot].v=v;
a[++tot].y=x;a[tot].next=linkk[y];
linkk[y]=tot;a[tot].v=0;//反向边
}
void init()
{
scanf("%d%d",&n,&m);
s=1+n;t=n;
for(int i=2;i<n;++i)
insert(i,i+n,1);//拆点
int x,y;
for(int i=1;i<=m;++i)
{
scanf("%d%d",&x,&y);
insert(x+n,y,MM);
insert(y+n,x,MM);//连边
}
return ;
}
bool bfs()
{
memset(vis,0,sizeof(vis));
int head=0,tail=1;
q[1]=s;vis[s]=1;inf[s]=MM;
while (++head<=tail)
{
int x=q[head];
for(int i=linkk[x];i;i=a[i].next)
if (a[i].v)
{
int y=a[i].y;
if (vis[y]) continue;
inf[y]=min(inf[x],a[i].v);
pre[y]=i;
vis[y]=1;q[++tail]=y;
if (y==t) return 1;
}
}
return 0;
}
void updata()
{
int x=t;
while (x!=s)
{
int i=pre[x];
a[i].v-=inf[t];
a[i^1].v+=inf[t];
x=a[i^1].y;
}
ans+=inf[t];
}
void work()
{
while (bfs())
updata();
if (!ans) printf("%d",ans);
else printf("%d",ans-1);
return ;
}
int main()
{
init();
work();
return 0;
}