ACM图论行云流水Word文件下载.docx

ACM图论行云流水Word文件下载.docx

《ACM图论行云流水Word文件下载.docx》由会员分享，可在线阅读，更多相关《ACM图论行云流水Word文件下载.docx（194页珍藏版）》请在冰豆网上搜索。

2）在层次图上进行dfs修改残余网络。

我们可以在层次图上进行多次增广。

3）重复1,2的过程，直到找不到增广路为止。

#include<

stdio.h>

string.h>

#defineINF999999999

#definemin（x,y）（x）>

（y）?

（y）:

（x）

structp

{

intv,t,k,next;

}edge[51000];

intn,m,k,S,T,head[510],tot,h[510];

voidaddedge（inta,intb,intk）

edge[tot].v=b;

edge[tot].k=k;

edge[tot].t=tot+1;

edge[tot].next=head[a];

head[a]=tot++;

edge[tot].v=a;

edge[tot].k=0;

edge[tot].t=tot-1;

edge[tot].next=head[b];

head[b]=tot++;

}

intbfs（）

inti,top,tail,cur,pop[510];

top=tail=0;

memset（h,0xff,sizeof（h））;

h[S]=0;

pop[top++]=S;

while（tail!

=top）

{

cur=pop[tail++];

for（i=head[cur];

i!

=-1;

i=edge[i].next）

if（edge[i].k>

0&

&

h[edge[i].v]==-1）

h[edge[i].v]=h[cur]+1;

pop[top++]=edge[i].v;

}

returnh[T]!

intdfs（intt,intflow）

inti,tmpf,f;

if（t==T）returnflow;

tmpf=0;

for（i=head[t];

h[edge[i].v]==h[t]+1&

tmpf<

flow&

（f=dfs（edge[i].v,min（edge[i].k,flow-tmpf））））

edge[i].k-=f;

edge[edge[i].t].k+=f;

tmpf+=f;

if（tmpf==0）h[t]=-1;

returntmpf;

intdinic（）

intmaxflow=0;

while（bfs（））

maxflow+=dfs（S,INF）;

returnmaxflow;

Sap+gap算法：

Dinic算法要多次计算层次图，增加了复杂度。

是不是可以不多次计算层次图呢？

答案是肯定，这就产生了SAP算法。

SAP计算的是反向图的层次图，这和原图的层次图是作用是一样的，当然其实Dinic也可以计算反向图的层次图。

计算反向图的层次图是便于重新给顶点标号，即重新确定其层次图。

具体做法为，当我们找到一条经过顶点i的增广路径后，对于所有边<

i,j>

，计算出m=min{h[j]}，这是我们就可以把i重新标号为h[i]=min+1。

实际上，我们可以首先不需要计算反向图的层次图，而是把所有顶点的层次标为0，这对效率没多大影响。

优化1）：

gap优化（cnt[]）。

所谓gap优化就是计算出层次图后，层次出现断层，这是可以确定残余网络中不存在增广路径了，算法就可以提前结束。

这个优化看似微小，实际作用确不小。

做法就是保存某一个标号在残余网络中出现的次数，如果是0，就断层了。

优化2）：

当前弧优化（cur[]、cur1[]）。

为了使每次找增广路的时间变成均摊O（V），还有一个重要的优化是对于每个点保存“当前弧”：

初始时当前弧是邻接表的第一条弧；

在邻接表中查找时从当前弧开始查找，找到了一条允许弧，就把这条弧设为当前弧；

改变距离标号时，把当前弧重新设为邻接表的第一条弧。

queue>

#defineINF99999999

usingnamespacestd;

inttot,n,m,S,T,h[410],head[510],cnt[510];

inti,tmpf,f,tmp;

tmpf=flow;

tmp=T;

if（h[t]==h[edge[i].v]+1&

edge[i].k>

0）

f=dfs（edge[i].v,min（edge[i].k,tmpf））;

tmpf-=f;

if（!

tmpf||h[S]==T+1）returnflow-tmpf;

if（h[edge[i].v]<

tmp&

0）tmp=h[edge[i].v];

（--cnt[h[t]]））h[S]=T+1;

elsecnt[h[t]=tmp+1]++;

returnflow-tmpf;

intsap_gap（）

intmaxflow;

maxflow=0;

memset（h,0,sizeof（h））;

memset（cnt,0,sizeof（cnt））;

while（h[S]<

T+1）

用最大流解路径问题

Poj2455Secret 

Milking 

Machinetime497

题意：

求从S到T的t条路径，且路径上的边都不同，且最大的边最小。

题解：

这类题，要的不是整体的最小费用，一般都是二分答案（最长所允许的边的费用），筛掉二分时mid之上费用的边，然后用最大流算看它是不是满流的来决定继续怎么分。

至于那个正反边都建的问题，其实它是不可能正反都走的，因为我们的目的是要让路径走的最长的那条尽可能短。

如果都走的话，看下面的图

A

/\

/\

B----C

\/

D

假设我们先走A->

B->

C->

D,再走A->

D。

那么实际上，我可以直接走A->

D和A->

C这一段是完全剩下的。

也就是说，对于任何一条被走正反两次的路，你正走的那个起点和反走的那个终点其实是同一个点，先前走的那条路的前一半A->

B,必然和之后走的路的后一半B->

D相连，对于另一边也是这样。

完全可以不走那段被重复走的。

而且如果走了中间那段，反而是多走的。

至于用单源最短路先定下边的方向，无法保证正确，仔细想想就很容易举出反例了。

代码：

intmain（）

intk,i,j,a,b,l,t,r,mid,ans;

while（scanf（"

%d%d%d"

&

n,&

m,&

k）!

=EOF）

l=INF,r=-1;

for（i=0;

i<

m;

i++）

scanf（"

a,&

b,&

t）;

if（t>

r）r=t;

if（t<

l）l=t;

line[i].a=a;

line[i].b=b;

line[i].k=t;

l--,r++;

S=n+1,T=n+2;

while（l+1!

=r）

mid=（l+r）/2;

tot=0;

memset（head,0xff,sizeof（head））;

if（line[i].k<

=mid）

addedge（line[i].a,line[i].b,1）;

addedge（line[i].b,line[i].a,1）;

addedge（S,1,k）;

addedge（n,T,k）;

if（dinic（）==k）ans=mid,r=mid;

elsel=mid;

printf（"

%d\n"

ans）;

return0;

最长递增子序列问题

题意：

给定正整数序列x1…xn.。

1.计算其最长递增子序列的长度s。

2.计算从给定的序列中最多可取出多少个长度为s的递增子序列。

3.如果允许在取出的序列中多次使用x1和xn，则从给定序列中最多可取出多少个长度为s的递增子序列。

首先动态规划求出dp[i]，表示以第i位为结尾的最长上升序列的长度，求出最长上升序列长度K。

然后把序列每位i拆成两个点<

i.a>

和<

i.b>

，从<

到<

连接一条容量为1的有向边。

建立附加源S和汇T，如果序列第i位有dp[i]=K，从<

到T连接一条容量为1的有向边。

如果dp[i]=0，从S到<

如果j>

i且d[i]<

d[j]且dp[j]=dp[i]+1，从<

j.a>

求网络最大流，就是第二问的结果。

把边（<

1.a>

<

1.b>

）（<

N.a>

N.b>

）（S,<

T）这四条边的容量修改为无穷大，再求一次网络最大流，就是第三问结果。

inti,j,k,max,d[1000],dp[1000];

%d"

n）!

if（n==0）continue;

for（i=1;

=n;

d[i]）;

memset（dp,0,sizeof（dp））;

max=0;

for（j=1;

j<

i;

j++）

if（d[j]<

d[i]&

dp[j]+1>

max）

max=dp[j]+1;

dp[i]=max;

if（max<

dp[i]）

max=dp[i];

max+1）;

S=0;

T=2*n+1;

addedge（i,i+n,1）;

if（dp[i]==0）addedge（S,i,1）;

if（dp[i]==max）addedge（i+n,T,1）;

for（j=i+1;

if（dp[j]==dp[i]+1&

d[j]>

d[i]）

addedge（i+n,j,1）;

dinic（））;

if（i==1||i==n）addedge（i,i+n,INF）;

elseaddedge（i,i+n,1）;

if（dp[i]==0&

i==1）addedge（S,i,INF）;

elseif（dp[i]==0）addedge（S,i,1）;

if（dp[i]==max&

i==n）addedge（i+n,T,INF）;

elseif（dp[i]==max）addedge（i+n,T,1）;

Zoj2760HowManyShortestPathtime80ms

题目大意：

求一个有向图中点到点的边不相交的最短路径条数。

算法：

floyd+最大流

思路：

先求出最短路径的大小，然后再每条边依次判断是否在最短路径上，如果在最短路径上则添加一条流量大小为1的边。

最后再求最大流，最大流值就是路径的条数。

判断边是否在最短路径上：

（其中map[i][j]是点i到点j的最短距离，dt[i][j]是边i到j的大小）

n;

for（j=0;

if（i!

=j&

dt[i][j]!

=-1&

map[S][i]!

map[j][T]!

map[S][T]==map[S][i]+dt[i][j]+map[j][T]）

addedge（i,j,1）;

//说明在最短路径上，则添边

inti,j,k,map[110][110],dt[110][110];

map[i][j]）;

dt[i][j]=map[i][j];

dt[i][i]=map[i][i]=0;

%d%d"

S,&

T）;

if（S==T）

inf\n"

）;

continue;

for（k=0;

k<

k++）

if（k!

=i）for（j=0;

if（j!

=i&

j!

=k）

if（map[i][k]!

map[k][j]!

（map[i][j]==-1||map[i][j]>

map[i][k]+map[k][j]））

map[i][j]=map[i][k]+map[k][j];

if（map[S][T]==-1）

0\n"

Sgu185Twoshortest

求1->

n的两条不相交的最短路（两条路径可以共顶点但是不能共边）

做法：

用spfa求出点1到各个点的最短路径，然后再if（dis[j]==dis[i]+map[i][j]）来判断边map[i][j]是否是在最短路径上，如果是就加到图里，结果就得到以1为顶点的最短路径树，1到树中任意一点的连线都是最短路径，首先把这些边加到网络流的边集中，容量为1。

跑一遍1到n的最大流，如果流量>

=2则有解，再从原点深搜路径即可。

确切的来说，只要在后来建的图中随便找一条路径均是原点到该点的最短路（注意边是单向的），又因为限制了流量是1，所以一条边只能选取一次，这样跑出来的流量就一定是不相交最短路的条数。

当然如果在后面建的最短路径树中直接求两条从1到n的路径是不行的，如下图：

如果边的长度都为1，当找的第一条路径是1->

4->

3->

6时，然后就找不到其他最短路径了，也即只能找到一条，但是图中明显有两条最短路径1->

2->

6和1->

5->

6所以直接求两条从1到n的路径是不行的，因此只能用最大流来做。

代码如下：

intspfa（）

inti,j,cur,tmp,mark[410],dis[410];

queue<

int>

que;

memset（mark,0,sizeof（mark））;

dis[i]=INF;

dis[1]=0;

mark[1]=1;

que.push

（1）;

while（!

que.empty（））

cur=que.front（）;

que.pop（）;

mark[cur]=0;

if（dis[edge[i].v]>

dis[cur]+edge[i].k）

dis[edge[i].v]=dis[cur]+edge[i].k;

if（mark[edge[i].v]==0）

mark[edge[i].v]=1;

que.push（edge[i].v）;

if（dis[n]==INF）return0;

tmp=tot;

S=0,T=n+1;

map[i][j]!

=-1）

if（dis[i]==dis[j]+map[j][i]）

addedge（j,i,1）;

if（dis[j]==dis[i]+map[i][j]）

addedge（S,1,2）;

addedge（n,T,2）;

return1;

voiddfs2（intt）

inti;

%d"

t）;

if（t==n）return;

if（i%2==0&

edge[i].k==0）

dfs2（edge[i].v）;

edge[i].k=1;

return;

inti,j,a,b,c;

m）;

memset（map,0xff,sizeof（map））;

c）;

if（map[a][b]==-1||map[a][b]>

c）

map[a][b]=map[b][a]=c;

if（map[i][j]!

addedge1（i,j,map[i][j]）;

if（spfa（）==0||sap_gap（）<

2）

Nosolution\n"

else

dfs2

（1）;

\n"

SPOJ962IntergalacticMap

题目大意：

在一个无向图中，一个人要从A点赶往B点，之后再赶往C点，且要求中途不能多次经过同一个点。

问是否存在这样的路线。

（3<

=N<

=30011,1<

=M<

=50011）

建模方法：

由于每个点只能走一次，似乎最短路之类的算法不能用，只有往网络流上靠。

将每个点i拆成两个点i’,i’’并加边（i’,i’’,1）就能轻易达到这个目的。

然后我们以B为源点，A、C为汇点，看能否增广两次。

inti,ca,a,b;

freopen（"

1.txt"

"

r"

stdin）;

ca）;

while（ca--）

b）;

addedge（a,b,1）;

addedge（b,a,1）;

S=n+1;

T=n+2;

addedge（S,2,2）;

addedge（1,T,1）;

addedge（3,T,1）;

if（dinic（）==2）printf（"

YES\n"

elseprintf（"

NO\n"

return