标签：多次 算法 iostream ace ring 基础 ret size 没有
dinic比较适合学习完km之后再学习。因为dinic感觉像是km的一种优化。总之难度不是特别大
好了，言归正传。先分析一下km为什么效率低下？因为km每一次寻找maxflow，就确确实实只会找一条增广路。但事实上，一个图可能会同时有多条增广路，假如能同时更新一批增广路，肯定就会比一次更新一条快嘛
那么怎么判是否存在增广路？
沿用km的思想，从一个点开始bfs。只是这一次就不再需要记录flow值，因为真正的解决增广路的过程在于后面的增广路。可是，假如单单bfs一遍，最后还是要完整的跑一遍dfs感觉有些浪费时间。明明已经bfs了一遍全部节点，那莫不如把bfs的深度记录下来，这样就按照dep严格加一的顺序dfs下来，一定（若路径上的边权全部为正值）会导向汇点。
好了，bfs之后，怎么dfs妮？
从源点开始，记录这个点的节点编号和可以流过的最大值。dfs每一条可行的边，然后更新即可。由于dfs是递归的嘛，所以也不再需要pre以记录前驱，只需要回溯的时候沿途更更新就好。
一个简洁的模板：
while(bfs()) ans+=dfs(src,maxflow);
完整模板：
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
const int MAX=1e5+5,INF=0x3f3f3f3f;
int n,m,src,tar;
int edge[MAX<<1],head[MAX],nxt[MAX<<1],wei[MAX<<1];
int flow[MAX],pre[MAX],cur[MAX],dep[MAX];
void insert(int,int,int,int);
int dinic();
bool bfs(int);
int dfs(int,int);
int main(){
freopen("test.in","r",stdin);
cin>>n>>m>>src>>tar;
for(int i=1;i<=m;++i){
int u,v,w; cin>>u>>v>>w;
insert(u,v,w,(i<<1)); insert(v,u,0,(i<<1)+1);
}
cout<<dinic()<<endl;
return 0;
}
void insert(int from,int to,int w,int id){
edge[id]=to; nxt[id]=head[from]; head[from]=id; wei[id]=w;
}
int dinic(){
int ans=0;
while(bfs(src)) ans+=dfs(src,INF);
return ans;
}
bool bfs(int s){
int line[MAX],l=0,r=1; line[r]=s;
memset(dep,0,sizeof(dep));
dep[s]=1;
while(l<r){
int u=line[++l];
for(int i=head[u];i;i=nxt[i]){
int v=edge[i];
if(!wei[i]||dep[v]) continue;
dep[v]=dep[u]+1;
line[++r]=v;
}
}
return dep[tar];
}
int dfs(int u,int flow){
if(u==tar||!flow) return flow;
int ans=0;
for(int i=head[u];i;i=nxt[i]){
int v=edge[i]; if(dep[v]!=dep[u]+1) continue;
int add=dfs(v,min(flow,wei[i]));
if(add){
flow-=add;
wei[i]-=add;
wei[i^1]+=add;
ans+=add;
}
}
return ans;
}
貌似，dinic中，只有一遍dfs到头就返回的那种流派才用得上。像上文所说的那样做法，加了优化反而被劣化了？？
dinic自身还有一个优化。由于dinic有一个dfs，而且还是一个TAG图，那么一个点就有可能走了多次。对一个点的dfs，当它从一条边转换到了另外一条边时，意味着上一条边已经被“榨干”，也就是说从当前bfs下，这个点再次走这条边不会再找到增广路了，重复走只会浪费时间。
当前弧优化就是记录一个点上次dfs走到了哪儿的玩意儿。将cur作为head，直接从cur开始dfs即可，之前走过的边不再需要访问。
只需再原来的基础上，加上一个cur的初始化：
for(int i=1;i<=n;++i) cur[i]=head[i];
以及实时更新：
for(int i=cur[u];i;i=nxt[i]){
cur[i]=i;
...
}
完整代码：
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
const int MAX=1e5+5,INF=0x3f3f3f3f;
int n,m,src,tar;
int edge[MAX<<1],head[MAX],nxt[MAX<<1],wei[MAX<<1];
int flow[MAX],pre[MAX],cur[MAX],dep[MAX];
void insert(int,int,int,int);
int dinic();
bool bfs(int);
int dfs(int,int);
int main(){
//freopen("test.in","r",stdin);
cin>>n>>m>>src>>tar;
for(int i=1;i<=m;++i){
int u,v,w; cin>>u>>v>>w;
insert(u,v,w,(i<<1)); insert(v,u,0,(i<<1)+1);
}
cout<<dinic()<<endl;
return 0;
}
void insert(int from,int to,int w,int id){
edge[id]=to; nxt[id]=head[from]; head[from]=id; wei[id]=w;
}
int dinic(){
int ans=0;
while(bfs(src)) ans+=dfs(src,INF);
return ans;
}
bool bfs(int s){
int line[MAX],l=0,r=1; line[r]=s;
memset(dep,0,sizeof(dep));
dep[s]=1;
while(l<r){
int u=line[++l];
for(int i=head[u];i;i=nxt[i]){
int v=edge[i];
if(!wei[i]||dep[v]) continue;
dep[v]=dep[u]+1;
line[++r]=v;
}
}
if(dep[tar]){
for(int i=1;i<=n;++i) cur[i]=head[i];
return true;
}
else return false;
}
int dfs(int u,int flow){
if(u==tar||!flow) return flow;
int ans=0;
for(int i=cur[u];i;i=nxt[i]){
cur[u]=i;
int v=edge[i]; if(dep[v]!=dep[u]+1) continue;
int add=dfs(v,min(flow,wei[i]));
if(add){
flow-=add;
wei[i]-=add;
wei[i^1]+=add;
ans+=add;
}
}
return ans;
}
近日有幸得到了kiana大佬的教学视频，做题的时候碰到了一道好题:P3227 [HNOI2013]切糕
洛谷上ac了，就没有注意具体用时。今天突然兴致勃发，想在内网上蹭一下刷题量，居然tle了两次。起初怀疑内网是不是太古老了，有什么禁忌，到最后发现，我的代码居然被大佬们好1600ms？？
那就优化吧。用
int add=dfs(v,min(w[i],flow));
//balabala
flow-=add; //here!! attentino!!
最后一句话之后要及时判断flow是否还有残留，如果没有的化及时break掉！
想不到吧，就这么一句话就能优化掉1100ms？？
敬告:千万不要偷懒用memset!!
memset(dep,0,sizeof(dep));
改成
for(int i=1;i<=tar;++i) dep[i]=0;
之后，又优化掉了100ms！！
注意，此优化极端玄学，请勿频繁使用！！
那就是，吸氧。成功再次优化300ms，最终耗时302ms
bool bfs(){
queue <int> line; line.push(src);
for(int i=1;i<=tar;++i) dep[i]=0; dep[src]=1;
while(!line.empty()){
int u=line.front(); line.pop();
for(int i=head[u];i;i=nxt[i]){
int v=edge[i]; if(!w[i]||dep[v]) continue;
dep[v]=dep[u]+1;
line.push(v);
}
}
if(dep[tar]){
for(int i=1;i<=tar;++i) cur[i]=head[i];
return true;
}
return false;
}
int dfs(int u,int flow){
if(u==tar||!flow) return flow;
int ans=0;
for(int i=cur[u];i;i=nxt[i]){
cur[u]=i;
int v=edge[i]; if(dep[v]!=dep[u]+1) continue;
int add=dfs(v,min(flow,w[i]));
if(add){
flow-=add;
ans+=add;
w[i]-=add;
w[i^1]+=add;
if(!flow) break;
}
}
return ans;
}
int dinic(){
int ans=0;
while(bfs()) ans+=dfs(src,INF);
return ans;
}
标签：多次 算法 iostream ace ring 基础 ret size 没有
原文地址：https://www.cnblogs.com/ticmis/p/13211009.html
