二分图、网络流模版总结
这个星期重新回去理解二分图和网络流的算法，觉得当初真的是有点傻萌，都不太了解就直接套模版……
关于二分图
关于二分图的概念不想吐槽了，太多而且好多都好乱，看了很多个什么概念总结结果发现有的人把最大匹配叫最佳匹配。反正是看的我一脸蛋疼，决定还是抛开概念吧，看着像啥用啥得了。
匈牙利算法：
其实就是不断寻找增广路。那么什么是增广路呢？
既然是二分图，我们先定义X集和Y集。然后我们对X集里面的点一个一个来，拿出一个没用过的X集的点（简记为i），找所有和它相连的Y集的点（简记为j），如果这个Y集的点没用过，那么这两个点在一起就行了，如果用过了，就dfs这个Y集中的点是被那个X集中的点用的（简记为i'），这时候还是一样，找所有和这个i'点相连的Y点……如果这样dfs很多次后终于找到一个Y集中的点是没有用到了，那么原来是j-i',j'-i''……现在就变成i（之前没用过）-j,i'-j',……,i''-j''(之前没用过），这样就多了一个匹配。
procedure addedge(j,k:longint);
begin
inc(tot);
edge[tot].toward:=k;
edge[tot].next:=first[j];
first[j]:=tot;
end;
function dfs(x:longint):boolean;
var
i,too:longint;
begin
i:=first[x];
while i>0 do begin
too:=edge[i].toward;
if not chose[too] then begin
chose[too]:=true;
if (match[too]=0) or dfs(match[too]) then begin
match[too]:=x;
exit(true);
end
end;
i:=edge[i].next;
end;
exit(false);
end;
procedure work;
var
ans,i:longint;
begin
ans:=0;
for i:=1 to tot1 do begin
fillchar(chose,sizeof(chose),false);
if dfs(i) then inc(ans);
end;
writeln(ans);
end;
KM算法
很神奇。用来解决最大权匹配（雾之概念）。其实就是边加上了权，求某个匹配使权值最大。这类问题前提是必须存在一个方案使得可以让X每个点都在某个匹配里面。
我们可以搞个标号lx(),ly(),如果有边i->j，那么保证lx(i)+ly(j)>cij（边的权值）。然后这样的标号方案是不唯一的，但是这样的标号一定满足大于等于所有匹配（所以就包括了那个最大的方案），那么我们可以找到一个最小的标号方案使它等于最大的方案。
经过什么构造矩阵还是什么鬼的（搞了一个晚上搞懂了但是不想解释），我们可以得到一个流程。
如果一个x点不能加进图里面，那么调整标号，取出那些所有不再dfs中走到的Y点，找到最小slack值（在dfs顺便处理出的，slack[j]=min{slack[j],lx[i]+ly[j]-cij},i为和j有边相连的点）。然后所有dfs中走到的X点的标号-最小slack值，所有走到的y点标号+最小slack值，同时slack数组也变了，也就是所有dfs中走到的Y点的slack值-最小slack值。再跑匈牙利，不行再改，直到可以。
type
arr=record
toward,next,from,cost:longint;
end;
const
maxm=1000000;
maxn=50000;
var
edge:array[0..maxm]of arr;
l,slack,first,match:array[0..maxn]of longint;//实际中我为了偷懒就直接开一个l，然后y集合的点编号统一加上n
chose:array[0..maxn]of boolean;
tot,n,m:longint;
function min(x,y:longint):longint;
begin
if x<y then exit(x);
exit(y);
end;
procedure addedge(j,k,l:longint);
begin
inc(tot);
edge[tot].from:=j;
edge[tot].toward:=k;
edge[tot].cost:=l;
edge[tot].next:=first[j];
first[j]:=tot;
end;
function dfs(x:longint):boolean;
var
i,too,value:longint;
begin
chose[x]:=true;
i:=first[x];
while i>0 do begin
too:=edge[i].toward;
value:=edge[i].cost;
if not chose[too] then
if l[x]+l[too]=value then begin
chose[too]:=true;
if (match[too]=0) or dfs(edge[match[too]].from) then begin
match[too]:=i;
exit(true);
end;
end
else
slack[too]:=min(slack[too],l[x]+l[too]-value);
i:=edge[i].next;
end;
exit(false);
end;
procedure relable;
var
i,delta:longint;
begin
delta:=maxlongint;
for i:=n+1 to n+m do
if not chose[i] then delta:=min(delta,slack[i]);
for i:=1 to n do
if chose[i] then dec(l[i],delta);
for i:=n+1 to n+m do
if chose[i] then inc(l[i],delta)
else dec(slack[i],delta);
end;
function km:longint;
var
i,ans:longint;
begin
for i:=1 to n do begin
fillchar(slack,sizeof(slack),$7f);
while true do begin
fillchar(chose,sizeof(chose),false);
if dfs(i) then break;
relable;
end;
end;
ans:=0;
for i:=n+1 to n+m do
inc(ans,edge[match[i]].cost);
exit(ans);
end;
procedure into;
var
i,j,k,h:longint;
begin
readln(n,m);
for i:=1 to n do
for j:=1 to m do begin
read(k);
addedge(i,j+n,k);
if k>l[i] then l[i]:=k;
end;
end;
begin
into;
writeln(km);
readln;
readln;
end.
更多：
二分图最大匹配的三个定理
1:最大匹配数 + 最大独立集 = n + m
2:二分图的最小覆盖数 = 最大匹配数
3:最小路径覆盖 = 最大独立集
最大独立集是指求一个二分图中最大的一个点集，该点集内的点互不相连。
最小顶点覆盖是指 在二分图中，用最少的点，让所有的边至少和一个点有关联。
最小路径覆盖是指一个不含圈的有向图G 中，G的一个路径覆盖是一个其结点不相交的路径集合P，图中的每一个结点仅包含于P 中的某一条路径。路径可以从任意结点开始和结束，且长度也为任意值，包括0.
几种模型
http://wenku.baidu.com/link?url=TiCZ5ILAyn7F5fHSKvwOxnr8J1TgCBOdHUtipi0E78fgVmXszj-8OMlgX8i4z-oPDFsPGbyM-3pvDYNweXwA5As7Lrn0CA7SVs71yZM6AAu
文章后面总结的五个基本模型。
网络流
很多的问题都可以转为网络流求解，所以这是个万能的骗分算法（雾）。
最大流
学的是sap，觉得这个东西很好懂。现在再看的时候发现以前自己总结的那些资料非常好，一下子就回忆起来的。所以不想讲
//蔡大神当初的模版
const maxn=1000000;
type edgetype=record
toward,cap,next:longint; //邻接表 toward是指向哪个点，cap是容量，next是下一条边。
end;
var
cur,first,dist,num:array[0..maxn] of longint; //cur为当前弧优化 first为该点指向的最后一条边（邻接表用） dist、num是用于层次数记录
edge:array[0..maxn] of edgetype; //邻接表
n,m,s,t,tot,i,j,a,b,c:longint; //tot是记边数
function min(x,y:longint):longint;
begin
if x<y then exit(x) else exit(y);
end;
procedure add(i,j,k:longint);
begin
edge[tot].toward:=j;
edge[tot].cap:=k;
edge[tot].next:=first[i];
first[i]:=tot;
inc(tot);
end;
procedure addedge(i,j,k:longint);
begin
add(i,j,k);
add(j,i,0);
end;
function sap(v,flow:longint):longint;
var i,j,tmp,more,now:longint;
begin
if v=t then exit(flow);
now:=0;
i:=cur[v]; //当前弧优化
while i<>-1 do
begin
tmp:=edge[i].toward;
if (edge[i].cap>0) and (dist[v]=dist[tmp]+1) then
begin
more:=sap(tmp,min(edge[i].cap,flow-now));
dec(edge[i].cap,more);
inc(edge[i xor 1].cap,more);
inc(now,more);
cur[v]:=i;
if now=flow then exit(flow);
end;
i:=edge[i].next;
end;
dec(num[dist[v]]);
if num[dist[v]]=0 then dist[s]:=t;
//这是个优化，成为gap优化。当该图的层次数中发现不存在某一层次，说明这个图已经断成两半了，根本无法连通，所以可以直接退出
inc(dist[v]);
inc(num[dist[v]]);
cur[v]:=first[v];
exit(now);
end;
function maxflow:longint;
var i,flow:longint;
begin
fillchar(dist,sizeof(dist),0);
fillchar(num,sizeof(num),0);
flow:=0;
num[0]:=t;
for i:= 0 to n do cur[i]:=first[i]; //当前弧初始化
while dist[s]<t do inc(flow,sap(s,maxlongint));
exit(flow);
end;
procedure init;
begin
readln(n,m,s,t); //n个点，m条边，s、t分别为起点终点
for i:= 1 to n do first[i]:=-1;
tot:=0;
for i:=1 to m do
begin
readln(a,b,c);
addedge(a,b,c);
end;
end;
Begin
init;
writeln(maxflow);
End.
附测试用数据：
Data:
6 10 1 6
1 3 3
1 4 2
1 2 3
4 2 1
3 4 1
2 5 4
5 4 1
3 6 2
4 6 4
5 6 1
Ans:7
最小费用最大流
spfa大法和zkw大法当时都学了。
而且当时蔡大神总结的也非常好（点赞)。所以也不想讲了。
zkw大法的话其实还是用标号思想啦，不行就调整在找，找到不行有调整再搞……然后关于跑有负边的zkw费用流，当时并不是很理解。现在再看重新想了下终于懂了……其实还是一样，同样是满足一个标号，Di≥Dj+cij(i->j),一般情况是当边是正的时D是从s到t递减，不断增大Di以求更多的边。现在边有负，所以是从s到t递增，解决方案很简单，先算出t到s每个点D是正数最小是多少，初始化一下标号，还是可以套用以前的式子。
扔个有负边的
//vijos1525 生命之泉
type
arr=record
toward,cap,cost,next:longint;
end;
const
maxn=50000;
var
edge:array[0..10000]of arr;
first,dist,slack:array[0..5000]of longint;
q:array[0..maxn]of longint;
chose:array[0..5000]of boolean;
i,j,k,l,s,t,n,m,tot,maxcost,maxflow,kk:longint;
procedure add(i,j,k,l:longint);
begin
edge[tot].toward:=j;
edge[tot].cap:=k;
edge[tot].cost:=l;
edge[tot].next:=first[i];
first[i]:=tot;
inc(tot);
end;
procedure addedge(i,j,k,l:longint);
begin
add(i,j,k,l);
add(j,i,0,-l);
end;
function min(x,y:longint):longint;
begin
if x>y then exit(y);
exit(x);
end;
procedure spfa;
var
head,tail,i,too,value:longint;
begin
fillchar(chose,sizeof(chose),false);
for i:=0 to t do dist[i]:=maxlongint;
head:=1;
tail:=1;
q[1]:=s;
chose[s]:=true;
dist[s]:=0;
while head<=tail do begin
j:=q[head];
i:=first[j];
while i<>-1 do begin
too:=edge[i].toward;
value:=edge[i].cost;
if (edge[i].cap>0) and (dist[too]>dist[j]+value) then begin
dist[too]:=dist[j]+value;
if not chose[too] then begin
inc(tail);
if tail=maxn then tail:=1;
q[tail]:=too;
chose[too]:=true;
end;
end;
i:=edge[i].next;
end;
inc(head);
if head=maxn then head:=1;
chose[j]:=false;
end;
end;
function aug(v,flow:longint):longint;
var
rec,ret,too,value,i:longint;
begin
if v=t then begin
inc(maxcost,(dist[t]-dist[s])*flow);
inc(maxflow,flow);
exit(flow);
end;
i:=first[v];
chose[v]:=true;
rec:=0;
while i<>-1 do begin
too:=edge[i].toward;
value:=edge[i].cost;
if (edge[i].cap>0) and (not chose[too]) then
if dist[v]=dist[too]+value then begin
ret:=aug(too,min(flow-rec,edge[i].cap));
dec(edge[i].cap,ret);
inc(edge[i xor 1].cap,ret);
inc(rec,ret);
if rec=flow then exit(flow);
end else
slack[too]:=min(slack[too],dist[too]+value-dist[v]);
i:=edge[i].next;
end;
exit(rec);
end;
function rel:boolean;
var
spent,i:longint;
begin
spent:=maxlongint;
for i:=0 to t do
if not chose[i] then spent:=min(spent,slack[i]);
if spent=maxlongint then exit(false);
for i:=0 to t do
if chose[i] then inc(dist[i],spent);
exit(true);
end;
procedure costflow;
begin
spfa;
for i:=0 to t do
dist[i]:=-dist[i];
repeat
for i:=0 to t do slack[i]:=maxlongint;
repeat
fillchar(chose,sizeof(chose),false);
until aug(s,maxlongint)<=0;
until not rel;
end;
procedure into;
begin
readln(n,m,kk);
s:=0;
t:=n+2;
tot:=0;
for i:=0 to t do first[i]:=-1;
addedge(1,t,kk,0);
addedge(s,n+1,kk,0);
for i:=1 to m do begin
readln(j,k,l);
addedge(k+1,j,1,-l);
end;
for i:=1 to n do
addedge(i+1,i,maxlongint,0);
end;
Begin
into;
costflow;
writeln(maxcost);
readln;
readln;
End.
关于更多
有上下界的网络流，费用流：这个看书上说的balabala说是要见好多个附加网络神马的，然后看hzw大神的代码发现根本不需要那么麻烦，似乎只有多加个超汇点和超源点判断是否可行，建边要拆开，上界-下界的结果直接建，然后下界起点连超汇点，超源点连边终点，然后再用原源点和原汇点跑一边，两次答案相加就是最大流答案了？
以前做了好多还是用几天时候回顾下看看当时是不是比较傻就直接过了？
