陈义明的作业Word格式文档下载.docx
《陈义明的作业Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《陈义明的作业Word格式文档下载.docx（11页珍藏版）》请在冰豆网上搜索。
constintMAXN=150;
intuN,vN;
//u,v数目
intg[MAXN][MAXN];
intlinker[MAXN];
boolused[MAXN];
booldfs（intu）//从左边开始找增广路径
{
intv;
for（v=0;
v<
vN;
v++）//这个顶点编号从0开始，若要从1开始需要修改
if（g[u][v]&
&
!
used[v]）
{
used[v]=true;
if（linker[v]==-1||dfs（linker[v]））
{//找增广路，反向
linker[v]=u;
returntrue;
}
returnfalse;
}
inthungary（）
intres=0;
intu;
memset（linker,-1,sizeof（linker））;
for（u=0;
u<
uN;
u++）
memset（used,0,sizeof（used））;
if（dfs（u））res++;
returnres;
//*************************************************
intmain（）
intk;
intn;
intu,v;
intT;
scanf（"
%d"
&
T）;
while（T--）
%d%d"
n,&
k）;
memset（g,0,sizeof（g））;
while（k--）
u,&
v）;
u--;
v--;
g[u][v]=1;
uN=vN=n;
printf（"
%d\n"
n-hungary（））;
return0;
2、hdoj1150MachineSchedule
题意：
有两台机器A和B以及N个需要运行的任务。
每台机器有M种不同的模式，而每个任务都恰好在一台机器上运行。
如果它在机器A上运行，则机器A需要设置为模式ai,如果它在机器B上运行，则机器A需要设置为模式bi。
每台机器上的任务可以按照任意顺序执行，但是每台机器每转换一次模式需要重启一次。
请合理为每个任务安排一台机器并合理安排顺序，使得机器重启次数尽量少。
求二分图的最小顶点覆盖数=最大匹配数
#include<
cstdio>
cstdlib>
cstring>
constintMAXN=105;
intuN,vN;
//u,v数目，要初始化！
！
boolg[MAXN][MAXN];
//g[i][j]表示xi与yj相连
intxM[MAXN],yM[MAXN];
//输出量
boolchk[MAXN];
//辅助量检查某轮y[v]是否被check
intn,m,k;
booldfs（intu）{
for（v=0;
v<
vN;
v++）
if（g[u][v]&
!
chk[v]）
chk[v]=true;
if（yM[v]==-1||dfs（yM[v]））
yM[v]=u;
xM[u]=v;
returntrue;
returnfalse;
intpipei（）{
intu,ret=0;
memset（xM,-1,sizeof（xM））;
memset（yM,-1,sizeof（yM））;
for（u=0;
u<
uN;
u++）
if（xM[u]==-1）{
memset（chk,false,sizeof（chk））;
if（dfs（u））ret++;
returnret;
while（scanf（"
&
n）!
=EOF&
n!
=0）
m,&
memset（g,0,sizeof（g））;
for（inti=0;
i<
k;
i++）
{
inta,b,c;
scanf（"
%d%d%d"
a,&
b,&
c）;
if（b&
c）
g[b][c]=true;
}
uN=n;
vN=m;
pipei（））;
3、poj1273DrainageDitches
农夫约翰修建了一套排水系统来使贝茜的草地免除被大水淹没的烦恼（雨水会流向附近的一条小溪）。
农夫约翰已经在每条排水沟的一端安上了控制器，这样他可以控制流入排水沟的水流量。
>
农夫约翰知道每一条排水沟每分钟可以流过的水量，和排水系统的准确布局（起点为水潭而终点为小溪的一张网）。
需要注意的是，有些时候从一处到另一处不只有一条排水沟。
根据这些信息，计算从水潭排水到小溪的最大流量。
对于给出的每条排水沟，雨水只能沿着一个方向流动，注意可能会出现雨水环形流动的情形。
其中数据中有重边，输入均为单向边
给m个关系,n点，求1到n的最大流
Edmonds_Karp算法
queue>
intn,m;
intcap[210][210];
//残余流量
intE_K（ints,intt）
intflow[210][210];
//已用流量;
intf=0,a[210],p[210];
queue<
int>
q;
memset（flow,0,sizeof（flow））;
while
（1）
memset（a,0,sizeof（a））;
a[s]=INT_MAX;
q.push（s）;
while（!
q.empty（））
intu=q.front（）;
q.pop（）;
for（intv=1;
=n;
v++）
{
if（!
a[v]&
cap[u][v]>
flow[u][v]）
{
q.push（v）;
a[v]=a[u]<
cap[u][v]-flow[u][v]?
a[u]:
cap[u][v]-flow[u][v];
p[v]=u;
}
}
if（a[t]==0）
break;
for（intu=t;
u!
=s;
u=p[u]）
flow[p[u]][u]+=a[t];
flow[u][p[u]]-=a[t];
f+=a[t];
returnf;
inti,from,to,w;
while（scanf（"
m,&
n）!
=EOF）
memset（cap,0,sizeof（cap））;
for（i=0;
i<
m;
i++）
from,&
to,&
w）;
cap[from][to]+=w;
//可能有重边,需叠加
printf（"
E_K（1,n））;
4、poj1459PowerWork
题目大意：
总共有n个节点，其中有发电站np个、用户nc个和调度器n-np-nc个三种节点，每个发电站有一个最大发电量，每个用户有个最大接受电量，现在有m条有向边，边有一个最大的流量代表，最多可以流出这么多电，现在从发电站发电到用户，问最多可以发多少电
解题思路：
将发电站看成源点，用户看成汇点，这样求最大流就可以了，不过因为有多个源点和汇点，所以加一个超级源点指向所有的发电站，流量为无限大，加一个超级汇点让所有的用户指向他，流量也为无限大，这样，从超级源点到超级汇点求最大流即可。
Dinic算法：
#definemin（a,b）（a<
b?
a:
b）
#defineMAXV105
#defineMAXINTINT_MAX
typedefstruct{
intflow;
//流量
intcapacity;
//最大容量值
}maps;
mapsmap[MAXV][MAXV];
intdis[MAXV];
//用于dinic分层
intvertime;
//顶点总数
intnedges;
//边的总数
intpower_stations;
//发电站总数
intconsumers;
//消费者总数
intmaxflow;
//最大流
intsp,fp;
//标记源点与汇点
boolbfs（）{
intv,i;
queue<
q;
memset（dis,0,sizeof（dis））;
q.push（sp）;
dis[sp]=1;
while（!
q.empty（））{
v=q.front（）;
q.pop（）;
for（i=1;
=vertime;
if（!
dis[i]&
map[v][i].capacity>
map[v][i].flow）{
q.push（i）;
dis[i]=dis[v]+1;
if（v==fp）return1;
intdfs（intcur,intcp）{
if（cur==fp）returncp;
inttmp=cp,t;
for（inti=1;
if（dis[i]==dis[cur]+1&
tmp&
map[cur][i].capacity>
map[cur][i].flow）{
t=dfs（i,min（map[cur][i].capacity-map[cur][i].flow,tmp））;
map[cur][i].flow+=t;
map[i][cur].flow-=t;
tmp-=t;
returncp-tmp;
voiddinic（）{
maxflow=0;
while（bfs（））maxflow+=dfs（sp,MAXINT）;
intmain（）{
inti;
intx,y,z;
charch;
%d%d%d%d"
vertime,&
power_stations,&
consumers,&
nedges）!
=EOF）{
//Init
memset（map,0,sizeof（map））;
//ReadGragh
=nedges;
i++）{//设置读图从1开始
cin>
ch>
x>
y>
z;
map[x+1][y+1].capacity=z;
//BuildGragh
//建立超级源点指向所有的发电站
sp=vertime+1;
fp=vertime+2;
vertime+=2;
for（i=1;
i<
=power_stations;
i++）{
y;
map[sp][x+1].capacity=y;
//建立超级汇点，使所有消费者指向它
=consumers;
map[x+1][fp].capacity=y;
dinic（）;
maxflow）;
升级会员 