mygraphWord下载.docx
《mygraphWord下载.docx》由会员分享，可在线阅读，更多相关《mygraphWord下载.docx（40页珍藏版）》请在冰豆网上搜索。
}
return-1;
intmain（）{
scanf（"
%d%d\n"
&
n,&
m）;
scanf（"
%d%d%d\n"
es[i].x,&
es[i].y,&
es[i].len）;
sort（es+1,es+m+1,cmp）;
printf（"
%d\n"
kruskal（））;
return0;
次小生成树
#defineinf1147483647
#defineN600
#defineVSN
#defineES800000
queue>
stdio.h>
string.h>
structheapnode{
intid,w;
heapnode（）{
heapnode（int_id,int_w）:
id（_id）,w（_w）{
};
booloperator<
（heapnodea,heapnodeb）{
returna.w>
b.w;
intto,w;
edge*next;
}edges[ES];
intes=0;
structGraph{
voidins（intx,inty,intw）{
edge*t=&
edges[++es];
t->
to=y;
w=w;
next=tail[x];
tail[x]=t;
mat[x][y]=min（mat[x][y],w）;
Graph（）{
init（）;
voidinit（）{
memset（tail,0,sizeof（tail））;
memset（mat,127,sizeof（mat））;
intprim（）;
edge*tail[VS];
intmat[VS][VS];
}G;
structTree{
intsub_spaning_tree（）{
intret=inf;
for（inti=1;
i++）{
intt=bfs（i）;
if（t<
ret）
ret=t;
returnret;
intbfs（intB）{
queue<
int>
Q;
boolvis[VS];
memset（vis,0,sizeof（vis））;
Q.push（B）;
while（Q.empty（）==false）{
intt=Q.front（）;
Q.pop（）;
for（edge*p=tail[t];
p;
p=p->
next）{
intto=p->
to;
if（!
vis[to]）{
W[B][to]=max（p->
w,W[B][t]）;
if（ret>
G.mat[B][to]-W[B][to]&
&
B!
=t）
ret=G.mat[B][to]-W[B][to];
vis[to]=true;
Q.push（to）;
}
}
Tree（）{
intW[N][N];
}T;
voidinput（）{
G.init（）;
T.init（）;
%d%d"
intx,y,w;
%d%d%d"
x,&
y,&
w）;
G.ins（x,y,w）;
G.ins（y,x,w）;
intGraph:
:
prim（）{
priority_queue<
heapnode>
intdis[N];
boolvis[N];
intpre[N];
intret=0;
memset（vis,0,sizeof（vis））;
memset（dis,127,sizeof（dis））;
Q.push（heapnode（1,0））;
dis[1]=0;
pre[1]=-1;
heapnodet;
Q.push（heapnode（0,2147483647））;
for（t=Q.top（）,Q.pop（）;
vis[t.id];
Q.top（）,Q.pop（））
;
if（!
t.id）
return-1;
if（pre[t.id]>
0）{
T.ins（pre[t.id],t.id,t.w）;
T.ins（t.id,pre[t.id],t.w）;
vis[t.id]=true;
ret+=t.w;
for（edge*p=tail[t.id];
intto=p->
if（dis[to]>
p->
w）{
dis[to]=p->
w;
Q.push（heapnode（to,p->
w））;
pre[to]=t.id;
returnret;
freopen（"
x.in"
"
r"
stdin）;
input（）;
intt=G.prim（）;
intsT=T.sub_spaning_tree（）;
cout<
<
"
Cost:
"
t<
endl;
;
if（sT==inf）
cout<
-1<
else
sT+t<
单点度限制生成树
//#defineDE
#defineinf1047483647
#defineVS40
#defineES800
algorithm>
map>
string>
structnameid{
intoperator[]（strings）{
if（list.find（s）!
=list.end（））
returnlist[s];
list[s]=++size;
#ifdefDE
Name[size]=s;
#endif
returnsize;
map<
string,int>
list;
nameid（）:
size（0）{
intsize;
stringName[VS];
}ID;
mat[x][y]=w;
mat[y][x]=w;
voiddel（intx,inty）{
mat[x][y]=-1;
mat[y][x]=-1;
memset（mat,-1,sizeof（mat））;
structt_edge{
intx,y,w;
t_edge（）{
t_edge（inta,intb,intc）:
x（a）,y（b）,w（c）{
boolcmp（t_edgea,t_edgeb）{
returna.w<
t_edgeedges[ES];
TreesubT;
intlb[VS];
boolvis[VS];
boolused[VS];
intf[VS];
intRoot;
intlbs;
intes;
intminid,mindeta,minX,minY;
intmakelab（）{
intret=0;
lbs=0;
memset（vis,false,sizeof（vis））;
mat[0][Root]=inf;
mat[Root][0]=inf;
for（inti=2;
=ID.size;
if（!
vis[i]）{
intj=0;
dfs（i,++lbs,j）;
used[j]=true;
subT.ins（Root,j,mat[Root][j]）;
ret+=mat[Root][j];
voiddfs（intid,intlab,int&
minp）{
if（mat[Root][id]>
0&
mat[Root][id]<
mat[Root][minp]）
minp=id;
vis[id]=true;
lb[id]=lab;
if（i==Root）
continue;
vis[i]&
mat[id][i]>
0）
dfs（i,lab,minp）;
intgf（intx）{
if（f[x]!
f[x]=gf（f[x]）;
returnf[x];
intkruskal（）{
sort（edges+1,edges+1+es,cmp）;
intret=0,cnt=0;
f[i]=i;
=es;
intx=edges[i].x,y=edges[i].y;
if（x==Root||y==Root）
if（gf（x）!
=gf（y））{
f[gf（x）]=gf（y）;
ret+=edges[i].w;
subT.ins（x,y,edges[i].w）;
if（++cnt==ID.size-1-lbs）
break;
es=0;
Root=ID["
Park"
];
edges[++es]=t_edge（x,y,w）;
voiddfs（intu,intpre,intmaxwid,intw）{
vis[u]=true;
subT.mat[u][i]>
i!
=Root）{
inttmaxwid=maxwid,tw=w,tpre=pre;
if（mat[u][i]>
w）
tw=mat[u][i];
if（tw>
tpre=u;
tmaxwid=i;
if（mat[Root][i]>
mindeta>
-tw+mat[Root][i]&
!
used[i]）{
minid=i;
mindeta=-tw+mat[Root][i];
minX=tpre;
minY=tmaxwid;
dfs（i,tpre,tmaxwid,tw）;
intKlimitspanningtree（intlimT）{
intret,ans=makelab（）;
ans+=kruskal（）;
ret=ans;
for（intk=lbs+1;
k<
=limT;
k++）{
memset（vis,false,sizeof（vis））;
mindeta=inf;
for（inti=1;
if（used[i]）
dfs（i,0,0,0）;
if（mindeta>
=0）
subT.ins（Root,minid,mat[Root][minid]）;
subT.del（minX,minY）;
used[minid]=true;
ans+=mindeta;
if（ret>
ans）
ret=ans;
intn,lim;
cin>
>
n;
strings1,s2;
intw;
cin>
s1>
s2>
G.ins（ID[s1],ID[s2],w）;
G.ins（ID[s2],ID[s1],w）;
lim;
Totalmilesdriven:
G.Klimitspanningtree（lim）<
G.subT.show（）;
最小树形图
doubleconstoo=1e8;
doubleg[103][103];
intpre[103],vis[103],del[103];
intN,M;
inlinevoidupdate（double&
x,doubley）{
if（y<
x）
x=y;
doubleMinTreeGraph（）{
memset（del,0,sizeof（del））;
doubleret=0;
while（true）{
intcheck=1;
for（inti=2;
i<
=N;
if（del[i]）
pre[i]=i,g[i][i]=oo;
for（intj=1;
j<
j++）{
if（del[j]）
continue;
if（g[j][i]<
g[pre[i]][i]）
pre[i]=j;
memset（vis,0,sizeof（vis））;
intnode=i;
while（node!
=1&
!
vis[node]）{
vis[node]=1,node=pre[node];
if（node==1）
check=0;
intt=node;
ret+=g[pre[node]][node];
node=pre[node];
=t）{
ret+=g[pre[node]][node],del[node]=1,node=pre[node];
if（g[j][t]!
=oo）
g[j][t]=g[j][t]-g[pre[t]][t];
node=pre[t];
for（intk=1;
k<
if（del[k]）
continue;
update（g[t][k],g[node][k]）;
if（g[k][node]!
update（g[k][t],g[k][node]-g[pre[node]][node]）;
node=pre[node];
break;
if（check）{
for（inti=2;
if（del[i]）
ret+=g[pre[i]][i];
Dijkstra
#defineVS101001
#defineES201001
#defineINT_MAX0x7f7f7f7f
functional>
intdis[VS];
inttail[VS];
intpre[2*ES];
intto[2*ES];
intlen[2*ES];
structqE{
intlen,idx;
qE（intl,inti）:
len（l）,idx（i）{
qE（）{
booloperator<
（constqE&
a,constqE&
b）{
returna.len>
voidaddedge（intx,inty,intt）{
pre[++es]=tail[x];
len[es]=t;
to[es]=y;
tail[x]=es;
voidinit（）{
memset（pre,-1,sizeof（pre））;
memset（tail,-1,sizeof（pre））;
intdijkstra（ints,intt）{
qE>
Q.push（qE（0,s））;
dis[s]=0;
while（!
Q.empty（））{
qEt;
do{
t=Q.top（）;
}while（dis[t.idx]!
=t.len&
Q.empty（））;
for（intp=tail[t.idx];
p>
0;
p=pre[p]）{
if（dis[to[p]]>
t.len+len[p]）{
dis[to[p]]=t.len+len[p];
Q.push（qE（dis[to[p]],to[p]））;
if（dis[t]==INT_MAX）
return-1;
returndis[t];
init（）;
intx,y,t;
t）;
addedge（x,y,t）;
addedge（y,x,t）;
dijkstra（1,n））;
r
升级会员 