二分图匹配题目类型总结.docx

二分图匹配题目类型总结.docx

《二分图匹配题目类型总结.docx》由会员分享，可在线阅读，更多相关《二分图匹配题目类型总结.docx（29页珍藏版）》请在冰豆网上搜索。

二分图匹配题目类型总结

二分图匹配题目类型总结

二分图最大匹配的匈牙利算法

二分图是这样一个图，它的顶点可以分类两个集合X和Y，所有的边关联在两个顶点中，恰好一个属于集合Ｘ，另一个属于集合Ｙ。

最大匹配：

图中包含边数最多的匹配称为图的最大匹配。

完美匹配：

如果所有点都在匹配边上（x=y=m），称这个最大匹配是完美匹配。

最小点覆盖：

（二分图）最小覆盖要求用最少的点（Ｘ集合或Ｙ集合的

都行）让每条边都至少和其中一个点关联。

可以证明：

最少的点（即覆盖数）＝

最大匹配数。

支配集：

（二分图）最小点覆盖数+孤立点

最小边覆盖：

找最大匹配（注意可能是任意图最大匹配）m

则有2*m个点被m条两两不相交的边覆盖。

对于剩下的n-2*m个点，每个点用

一条边覆盖，总边数为n-m条;

最小路径覆盖：

用尽量少的不相交简单路径覆盖有向无环图Ｇ的所有结点。

解决此类问题可以建立一个二分图模型。

把所有顶点i拆成两个：

Ｘ结点集中的i和Y结点集中的i',如果有边i->j，则在二分图中引入边i->j'，设二分图最大匹配为m,则结果就是n-m。

最大独立集问题：

（二分图）n-最小点覆盖;

任意图最大匹配：

（没有奇环）转换为二分图：

把所有顶点i拆成两个：

Ｘ结点集中的i和Y结点集中的i',如果原图中有边i->j，则在二分图中引入边i->j',j->i’；设二分图最大匹配为m,则结果就是m/2。

最大完全子图：

补图的最大独立集

三大博弈问题

威佐夫博奕（WythoffGame）：

有两堆各若干个物品，两个人轮流从某一堆或同时从两堆中取同样多的物品，规定每次至少取一个，多者不限，最后取光者得胜。

这种情况下是颇为复杂的。

我们用（ak，bk）（ak≤bk,k=0，1，2，...,n）表示两堆物品的数量并称其为局势，如果甲面对（0，0），那么甲已经输了，这种局势我们称为奇异局势。

前几个奇异局势是：

（0，0）、（1，2）、（3，5）、（4，7）、（6，10）、（8，13）、（9，15）、（11，18）、（12，20）。

可以看出,a0=b0=0,ak是未在前面出现过的最小自然数,而bk=ak+k，奇异局势有

如下三条性质：

1。

任何自然数都包含在一个且仅有一个奇异局势中。

由于ak是未在前面出现过的最小自然数，所以有ak>ak-1，而bk=ak+k>ak-1+k-1=bk-1>ak-1。

所以性质1。

成立。

2。

任意操作都可将奇异局势变为非奇异局势。

事实上，若只改变奇异局势（ak，bk）的某一个分量，那么另一个分量不可能在其他奇异局势中，所以必然是非奇异局势。

如果使（ak，bk）的两个分量同时减少，则由于其差不变，且不可能是其他奇异局势的差，因此也是非奇异局势。

3。

采用适当的方法，可以将非奇异局势变为奇异局势。

假设面对的局势是（a,b），若b=a，则同时从两堆中取走a个物体，就变为了奇异局势（0，0）；如果a=ak，b>bk，那么，取走b-bk个物体，即变为奇异局势；如果a=ak，bak，b=ak+k,则从第一堆中拿走多余的数量a-ak即可；如果a

从如上性质可知，两个人如果都采用正确操作，那么面对非奇异局势，先拿者必胜；反之，则后拿者取胜。

那么任给一个局势（a，b），怎样判断它是不是奇异局势呢？

我们有如下公式：

ak=[k（1+√5）/2]，bk=ak+k（k=0，1，2，...,n方括号表示取整函数）

奇妙的是其中出现了黄金分割数（1+√5）/2=1。

618...,因此,由ak，bk组成的矩形近似为黄金矩形，由于2/（1+√5）=（√5-1）/2，可以先求出j=[a（√5-1）/2]，若a=[j（1+√5）/2]，那么a=aj，bj=aj+j，若不等于，那么a=aj+1，bj+1=aj+1+j+1，若都不是，那么就不是奇异局势。

然后再按照上述法则进行，一定会遇到奇异局势。

巴什博奕（BashGame）：

只有一堆n个物品，两个人轮流从这堆物品中取物，规定每次至少取一个，最多取m个。

最后取光者得胜。

显然，如果n=m+1，那么由于一次最多只能取m个，所以，无论先取者拿走多少个，后取者都能够一次拿走剩余的物品，后者取胜。

因此我们发现了如何取胜的法则：

如果n=（m+1）r+s，（r为任意自然数，s≤m）,那么先取者要拿走s个物品，如果后取者拿走k（≤m）个，那么先取者再拿走m+1-k个，结果剩下（m+1）（r-1）个，以后保持这样的取法，那么先取者肯定获胜。

总之，要保持给对手留下（m+1）的倍数，就能最后获胜。

这个游戏还可以有一种变相的玩法：

两个人轮流报数，每次至少报一个，最多报十个，谁能报到100者胜

尼姆博奕（NimmGame）：

有三堆各若干个物品，两个人轮流从某一堆取任意多的物品，规定每次至少取一个，多者不限，最后取光者得胜。

这种情况最有意思，它与二进制有密切关系，我们用（a，b，c）表示某种局势，首先（0，0，0）显然是奇异局势，无论谁面对奇异局势，都必然失败。

第二种奇异局势是（0，n，n），只要与对手拿走一样多的物品，最后都将导致（0，0，0）。

仔细分析一下，（1，2，3）也是奇异局势，无论对手如何拿，接下来都可以变为（0，n，n）的情形。

计算机算法里面有一种叫做按位模2加，也叫做异或的运算，我们用符号（+）表示这种运算。

这种运算和一般加法不同的一点是1+1=0。

先看（1，2，3）的按位模2加的结果：

1=二进制01

2=二进制10

3=二进制11（+）

———————

0=二进制00（注意不进位）

对于奇异局势（0，n，n）也一样，结果也是0。

任何奇异局势（a，b，c）都有a（+）b（+）c=0。

如果我们面对的是一个非奇异局势（a，b，c），要如何变为奇异局势呢？

假设a

a（+）b（+）（a（+）b）=（a（+）a）（+）（b（+）b）=0（+）0=0。

要将c变为a（+）b，只要从c中减去c-（a（+）b）即可。

例1。

（14，21，39），14（+）21=27，39-27=12，所以从39中拿走12个物体即可达到奇异局势（14，21，27）。

例2。

（55，81，121），55（+）81=102，121-102=19，所以从121中拿走19个物品就形成了奇异局势（55，81，102）。

例3。

（29，45，58），29（+）45=48，58-48=10，从58中拿走10个，变为（29，45，48）。

例4。

我们来实际进行一盘比赛看看：

甲7,8,9）->（1,8,9）奇异局势

乙1,8,9）->（1,8,4）

甲1,8,4）->（1,5,4）奇异局势

乙1,5,4）->（1,4,4）

甲1,4,4）->（0,4,4）奇异局势

乙0,4,4）->（0,4,2）

甲0.4,2）->（0,2,2）奇异局势

乙0,2,2）->（0,2,1）

甲0,2,1）->（0,1,1）奇异局势

乙0,1,1）->（0,1,0）

甲0,1,0）->（0,0,0）奇异局势

甲胜。

ConvexHull3D

描述

Givennpointsin3Dspace,countthenumberoffacesoftheirconvexhull.Intheconvexhull,notwofacescanbecoplanar.

输入

ThefirstlinecontainsasingleintegerT（1≤T≤100）,thenumberoftestcases.Eachtestcasebeginswithalinecontainingasingleintegern（4≤n≤1000）,thenumberofpoints.

Inthefollowingnlines,eachcontainsthreeintegersx,y,z（-1000≤x,y,z≤1000）,thecoordinatesofeachpoint.

输出

Foreachtestcase,printthecasenumberandthenumberoffaces.Iftheconvexhullisempty（allthepointslieinasingleplane）,output0.

样例输入

3

4

100

010

001

000

4

000

010

110

100

9

000

020

220

200

002

022

222

202

111

样例输出

Case1:

4

Case2:

0

Case3:

6

#include

#include

#include

#include

#include

#include

usingnamespacestd;

#definetypedouble

constintmaxn=1005;

constintnotexist=-1;

constdoubleeps=1e-8;

structPoint

{

typex,y,z;

voidoperator-=（Pointother）{

x=x-other.x;

y=y-other.y;

z=z-other.z;

}

booloperator<（Pointother）const{

if（x!

=other.x）returnx

if（y!

=other.y）returny

returnz

}

booloperator==（Pointother）const{

returnfabs（x-other.x）+fabs（y-other.y）+fabs（z-other.z）

}

};

Pointp[maxn];//storethesetofpoints

intn;//numberofpoints

intf[10*maxn][3];//storethefaces

intfc;//numberoffaces

boolR[maxn][maxn];//（i,j,R[i][j]）isaface

typedelta3d（constPoint&A,constPoint&B,constPoint&C）

{

returnA.x*（B.y*C.z-B.z*C.y）

-A.y*（B.x*C.z-B.z*C.x）

+A.z*（B.x*C.y-B.y*C.x）;

}

typecross2d（PointA,PointB,PointC）

{

typea,b,c;

B.x-=A.x;

B.y-=A.y;

B.z-=A.z;

C.x-=A.x;

C.y-=A.y;

C.z-=A.z;

a=B.y*C.z-B.z*C.y;

b=B.x*C.z-B.z*C.x;

c=B.x*C.y-B.y*C.x;

returnsqrt（a*a+b*b+c*c）;

}

typecross3d（PointA,PointB,PointC,PointD）

{

B-=A;

C-=A;

D-=A;

returndelta3d（B,C,D）;

}

inlinevoidaddface（constint&pa,constint&pb,constint&pc）//（pa,pb,pc）

{

f[fc][0]=pa;

f[fc][1]=pb;

f[fc++][2]=pc;

}

inlinevoiddelface（inti）//removerelation（pa,pb,pc）fromR

{

f[i][0]=f[fc-1][0];

f[i][1]=f[fc-1][1];

f[i][2]=f[fc-1][2];

fc--;

}

doublesurface（）

{

inti;

doubleans=0;

for（i=0;i

ans/=2.0;

returnans;

}

doublevolume（）

{

inti;

doubleans=0;

for（i=0;i

ans/=6.0;

returnans;

}

voidConvexHull（）//n>=4,notwopointstakesthesameposition

{

inti,k,h,j;

typet;

fc=0;//setthenumberoffacestozero

for（i=2;ieps）{

swap（p[2],p[i]）;

break;

}

if（i==n）return;

for（i=3;ieps）{

swap（p[3],p[i]）;

break;

}

if（i==n）return;

addface（0,1,2）;

addface（2,1,0）;

for（k=3;k

i=0;

boolflag=0;

while（i

flag=1;

R[f[i][0]][f[i][1]]=1;

R[f[i][1]][f[i][2]]=1;

R[f[i][2]][f[i][0]]=1;

delface（i）;

}else{

R[f[i][0]][f[i][1]]=0;

R[f[i][1]][f[i][2]]=0;

R[f[i][2]][f[i][0]]=0;

i++;

}

if（!

flag）continue;

h=fc;

for（i=0;i

R[f[i][0]][f[i][1]]）{

if（R[f[i][1]][f[i][0]]）addface（f[i][1],f[i][0],k）;

if（R[f[i][2]][f[i][1]]）addface（f[i][2],f[i][1],k）;

if（R[f[i][0]][f[i][2]]）addface（f[i][0],f[i][2],k）;

}

}

}

intcountface（）

{

inti,j,ans=0;

for（i=0;i

for（j=0;j

if（fabs（cross3d（p[f[i][0]],p[f[j][0]],p[f[j][1]],p[f[j][2]]））

fabs（cross3d（p[f[i][1]],p[f[j][0]],p[f[j][1]],p[f[j][2]]））

fabs（cross3d（p[f[i][2]],p[f[j][0]],p[f[j][1]],p[f[j][2]]））

break;

}

if（j==i）ans++;

}

returnans;

}

intmain（）

{

intcas,i,j;

//freopen（"in.dat","r",stdin）;

scanf（"%d",&cas）;

for（j=1;j<=cas;j++）{

scanf（"%d",&n）;

for（i=0;i

sort（p,p+n）;

n=unique（p,p+n）-p;

ConvexHull（）;

printf（"Case%d:

%d\n",j,countface（））;

//printf（"%.4lf%.4lf\n",surface（）,volume（））;

}

return0;

}

Zoj2676分数划分要求构造解

#include

usingnamespacestd;

constintmaxn=200;

constintmaxm=1000;

constdoubleeps=1e-12;

constdoubledps=1e-6;

constdoublemaxw=1e11;

doublec[maxm],tc[maxm];

intb[maxm],op[maxm],next[maxm];

inte[maxn],d[maxn],p[maxn],que[maxn],reach[maxn];

boolmark[maxn];

intm,n,s,t,size,ns;

doubleflow,value;

doublemin（doublea,doubleb）{returna

a:

b;}

voidaddedge（intu,intv,doublex,intp）{

size++;

next[size]=e[u];

e[u]=size;

c[size]=x;

b[size]=v;

op[size]=p;

}

voidinit（）{

inti,a,b,x;

memset（e,-1,sizeof（e））;

s=1;t=n;ns=t+1;size=0;

for（i=1;i<=m;i++）{

scanf（"%d%d%d",&a,&b,&x）;

tc[i]=x;

addedge（a,b,x,size+2）;

addedge（b,a,x,size）;

}

}

voidcreate（doubleg）

{

inti;

doublex;

flow=value=0;

for（i=1;i<=m;i++）{

x=tc[i]-g;

if（x<0）value+=x;

c[2*i-1]=c[2*i]=x;

}

}

boolconnect（）{

inti,j,l,r;

memset（que,0,sizeof（que））;

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

for（i=0;i<=ns;i++）d[i]=ns;

d[s]=0;

que[1]=s;l=0;r=1;mark[s]=true;

l=0;r=1;

while（l

i=que[++l];

for（j=e[i];j>0;j=next[j]）

if（!

mark[b[j]]&&c[j]>eps）{

mark[b[j]]=true;

que[++r]=b[j];

d[b[j]]=d[i]+1;

}

}

return（d[t]

}

doubleaugment（int&top）{

inti;

doublex;

x=maxw;

for（i=top;i>=2;i--）{

x=min（x,c[p[que[i-1]]]）;

}

if（x

for（i=top;i>=2;i--）{

c[p[que[i-1]]]-=x;

c[op[p[que[i-1]]]]+=x;

if（c[p[que[i-1]]]

top=i-1;

p[que[i-1]]=next[p[que[i-1]]];

}

}

returnx;

}

doubledfs（）{

inti,u,v,top;

doublesum;

memset（que,0,sizeof（que））;

for（i=0;i<=ns;i++）p[i]=e[i];

que[1]=s;top=1;sum=0;

while（top>0）{

if（que[top]==t）{

sum+=augment（top）;

}

else{

u=que[top];

for（;p[u]>0;p[u]=next[p[u]]）{

v=b[p[u]];

if（p[v]>0&&c[p[u]]>eps&&d[v]==d[u]+1）break;

}

if（p[u]<=0）top--;

elseque[++top]=v;

}

}

returnsum;

}

voiddfss（intu）{

inti;

if（reach[u]）return;

reach[u]=1;

for（i=e[u];i>0;i=next[i]）

if（c[i]>eps）dfss（b[i]）;

}

voidmincut（doubleg）{

inti,num;

memset（reach,0,sizeof（reach））;

dfss（s）;

num=0;

for（i=1;i<=m;i++）

if（（reach[b[2*i]]^reach[b[2*i-1]]）||（tc[i]-g<=0））num++;

cout<

for（i=1;i<=m;i++）

if（（reach[b[2*i]]^reach[b[2*i-1]]）||（tc[i]-g<=0）