网络流的几个小优化

是不是觉得网络流的速度不尽人心？

优化1

优化1就是我们空间的优化，有时候我们打.other是不是打得心烦气燥？

我们可以在初始化时len=1，那么以后要访问k的other时只需要k^1就可以了，简单来说就是二进制最后一位由1变0，由0变1。

同时，有时候一条边的x也不大有用，所以我们一样可以省去，所以，这两个变量的省去让我们代码简洁易懂，又省空间，一举两得！

---

优化2（弧优化）

好了，当前弧优化是什么呢（虽然有些大佬自己推出了，但自己可能也不知道自己加了优化！）？

根据最大流或zkw费用流（不会的可以点开我的博客，我已经置顶了），每次搜过的边基本上都是流不了的了，如果再去搜会十分浪费。

那么，我们可以用一个数组保存每个点的搜到第几条边，每次用k慢慢跳到那跳边，再开始搜，同时，最后，再从第一条边开始搜到没搜的那条边的前一条，可以缩短一些时间！

但是，每次慢慢跳太慢，可以直接记录是哪条边，嘿嘿嘿，就不用前面慢慢找了！

当然，我给出最短的当前弧（最开始我打的那种长，但是稍稍快1ms左右QAQ，其实也差不了多少，还不如最短的好）。

zkw流（只含递归部分，其他照旧，顺便说一下，MCMF加不了这个优化！）：

#include<cstdio>
#include<cstring>
#include<algorithm>
using  namespace  std;
typedef  long  long  ll;
struct  node
{
    int  y,next;
    ll  c,k;
}a[201000];int  last[1000],len=1;
long  long  d[1100];
bool  v[1100];
int  n,m,st,ed;
ll  cost=0;
int  cur[1100];
inline void  ins(int  x,int  y,ll  c,ll  k)
{
    len++;
    a[len].y=y;a[len].c=c;a[len].k=k;
    a[len].next=last[x];last[x]=len;
    len++;
    a[len].y=x;a[len].c=0;a[len].k=-k;
    a[len].next=last[y];last[y]=len;
}
int  list[1100],head,tail;/*队列*/
inline  bool  spfa()
{
    memset(v,false,sizeof(v));v[ed]=true;/*判断是否进入队列*/
    memset(d,10,sizeof(d));d[ed]=0;/*从终点到这里要多少费用*/
    head=1;tail=2;list[head]=ed;/*从终点出发*/
    ll  inf=d[st];
    while(head!=tail)
    {
        int  x=list[head];
        for(int  k=last[x];k;k=a[k].next)
        {
			int  y=a[k].y,kl=k^1;
            if(a[kl].c>0/*由于是倒着搜的，所以边也要反向边*/  &&  a[kl].k+d[x]<d[y])/*判断边是否可行并更新*/
            {
                d[y]=a[kl].k+d[x];/*更新*/
                if(v[y]==false)
                {
                    v[y]=true;
					list[tail++]=y;if(tail==n+1)tail=1;
                }
            }
        }
        head++;
        if(head==n+1)head=1;
        v[x]=false;
    }
    return  d[st]!=inf;/*返回bool值*/
}
inline  ll  mymin(ll  x,ll  y){return  x<y?x:y;}/*找最小值*/
long  long  find(int  x,ll  f)
{
    if(x==ed)return  f;
    v[x]=true;
    ll  ans=0,t=0;
    for(int  k=cur[x];k;k=a[k].next)
    {
        int  y=a[k].y;
        if(v[y]==false/*这个点没走过才可以走，否则更新边的流量是会Balabala*/  &&  a[k].c>0  &&  d[x]-a[k].k==d[y])
        {
            ans+=t=find(y,mymin(a[k].c,f-ans));/*是不是很眼熟？*/
            a[k].c-=t;a[k^1].c+=t;cost+=t*a[k].k;
			cur[x]=k;//这个很重要，cur[x]要在if里面更新！否则会拖延时间 
			if(ans==f){v[x]=false;return  ans;}
        }
	}
    v[x]=false;
    return  ans;/*妥妥的像最大流*/
}
int  main()
{
    scanf("%d%d",&n,&m);
    st=1;ed=n;
    for(int  i=1;i<=m;i++)
    {
        int  x,y;
        ll  z,l;
        scanf("%d%d%lld%lld",&x,&y,&z,&l);
        ins(x,y,z,l);
    }
    ll  zans=0;
    while(spfa()==true)/*建图完成！*/
    {
    	memcpy(cur+1,last+1,(n<<2));//部分拷贝 
        zans+=find(st,ll(999999999999999));/*多次查找，找出所有增光路哦*/
    }
    printf("%lld %lld",zans,cost);
    return  0;
}

最大流（Dinic）：

#include<cstdio>
#include<cstring>
using  namespace  std;
struct  node
{
	int  y,c,next;
}a[210000];int  last[11000],n,m,len=1/*用异或代替.other*/,st,ed;
int  cur[11000];//当前弧 
inline  void  ins(int  x,int  y,int  c)
{
	len++;a[len].y=y;a[len].c=c;a[len].next=last[x];last[x]=len;
	len++;a[len].y=x;a[len].c=0;a[len].next=last[y];last[y]=len;
}
int  h[11000],list[11000],head=1,tail=n;
inline  bool  bt_()
{
	memset(h,0,sizeof(h));h[st]=1;
	head=1;tail=2;list[1]=st;
	while(head!=tail)
	{
		int  x=list[head];cur[x]=last[x];//别忘了初始化cur 
		for(int  k=last[x];k;k=a[k].next)
		{
			int  y=a[k].y;
			if(a[k].c>0  &&  h[y]==0)
			{
				list[tail++]=y;
				h[y]=h[x]+1;
			}
		}
		head++;
	}
	if(h[ed]>0)return  true;
	else  return  false;
}
inline  int  mymin(int  x,int  y){return  x<y?x:y;}
int  find(int  x,int  f)
{
	if(x==ed)return  f;
	int  s=0,t;
	for(int  k=cur[x];k;k=a[k].next)
	{
		int  y=a[k].y;
		if(h[y]==h[x]+1  &&  a[k].c>0)
		{
			s+=(t=find(y,mymin(a[k].c,f-s)));
			a[k].c-=t;a[k^1/*.other*/].c+=t;
			cur[x]=k;//在里面更新很重要 
			if(s==f)return  f;//满足就退出，这步也很重要 
		}
	}
	if(s==0)h[x]=0;
	return  s;
}
int  main()
{
	int  ans=0;
	scanf("%d%d%d%d",&n,&m,&st,&ed);
	for(int  i=1;i<=m;i++)
	{
		int  x,y,c;
		scanf("%d%d%d",&x,&y,&c);
		ins(x,y,c);
	}
	while(bt_()==true)ans+=find(st,999999999);
	printf("%d\n",ans);
	return  0;
}