1讲评图详解.docx

1讲评图详解.docx

《1讲评图详解.docx》由会员分享，可在线阅读，更多相关《1讲评图详解.docx（17页珍藏版）》请在冰豆网上搜索。

1讲评图详解

1002:

求顶点的出度

 ProblemDescription

设有一有向图G，采用邻接表存储，输入某一顶点的存储编号（下标），现要求设计一个函数，用于输出图中该顶点的出度。

 Input

有多组测试数据，每组数据的第一行表示图的顶点数n和图的边数e（0

 Output

输出指定顶点的出度值；若指定的顶点不存在，则输出“notexist”。

 SampleInput

44

ABCD

01

02

23

30

0

 SampleOutput

2

//输出顶点编号（下标）为v的度

voidALGraph:

:

OutDegree（intv）

{

if（v>=vertexNum||v<0）

{

cout<<"notexist"<

}

else

{

intds=0;

ArcNode*p;

p=adjlist[v].firstedge;

while（p）

{

ds++;

p=p->next;

}

cout<

}

}

#include

#include

usingnamespacestd;

structBian

{

inti;

Bian*next;

};

structDin

{

charc;

Bian*first;

};

classGragh

{

Dina[25];//定义结构体数组时不要加*号

intnum1,e;

public:

Gragh（intn,intm,chars[]）;

voidfun（intl）;

};

Gragh:

:

Gragh（intn,intm,chars[]）

{

intk;

inti,j;

num1=n;

e=m;

for（k=0;k

{

a[k].c=s[k];

a[k].first=NULL;

}

for（k=0;k

{

cin>>i>>j;

Bian*t=newBian;

t->i=j;

t->next=a[i].first;

a[i].first=t;

}

}

voidGragh:

:

fun（intl）

{

Bian*t=a[l].first;

intnum=0;

while（t）

{

num++;

t=t->next;

}

cout<

}

intmain（）

{

intn,m;

charc[25];

intl;

while（cin>>n>>m）

{

cin>>c;

Graght（n,m,c）;

cin>>l;

if（l>=n||l<0）//注意判断找不到顶点的情况，下标

cout<<"notexist"<

else

t.fun（l）;

}

return0;

}

1003:

邻接矩阵转为邻接表

 ProblemDescription

设有向图G，现给出其邻接矩阵，要求将其转化为邻接表（采用头插法存边）进行存储。

 Input

输入数据有多组

每组数据第一行为一个正整数n（0

接下来有n行，为有向图G的邻接矩阵

 Output

对于每组数据，输出有若干行，为该有向图中所有顶点的出边信息（空表不输出任何信息），每行最后均无空格，每两组数据之间有一空行，具体格式见样例。

 SampleInput

3

001

000

100

4

0101

1010

1001

0000

 SampleOutput

0->2

2->0

0->3->1

1->2->0

2->3->0

ALGraph:

:

ALGraph（inta[20][20],intn）

{

vertexNum=n;//顶点数

inti,j,k=0;

for（i=0;i

adjlist[i].firstedge=NULL;

for（i=0;i

for（j=0;j

if（a[i][j]==1）

{

ArcNode*s=newArcNode;s->adjvex=j;//生成一个边表结点s

s->next=adjlist[i].firstedge;//将结点s插入到结点i的边表的表头

adjlist[i].firstedge=s;

k++;

}

arcNum=k;//边数

}

#include

#include

usingnamespacestd;

structBian

{

inti;

Bian*next;

};

structDin

{

intc;

Bian*first;

};

classGragh

{

Dina[25];

intnum1;

public:

Gragh（intn,ints[55][55]）;

voidfun（）;

};

Gragh:

:

Gragh（intn,ints[55][55]）

{

intk;

inti,j;

num1=n;

for（k=0;k

{

a[k].c=k+1;

a[k].first=NULL;

}

for（i=0;i

for（j=0;j

{

if（s[i][j]==1）

{

Bian*t=newBian;

t->i=j;

t->next=a[i].first;

a[i].first=t;

}

}

}

voidGragh:

:

fun（）

{

for（inti=0;i

{

Bian*t=a[i].first;

intf=0;

while（t）

{

if（f==0）

{

cout<

f=1;

}

cout<<"->"<i;

t=t->next;

}

if（a[i].first）

cout<

}

}

intmain（）

{

intn;

intf=0;

inta[55][55];

while（cin>>n）

{

if（f==1）

cout<

for（inti=0;i

for（intj=0;j

cin>>a[i][j];

Graght（n,a）;

t.fun（）;

f=1;

}

return0;

}

1002:

求连通分量

 ProblemDescription

设有一无向图，其顶点值为字符型并假设各值互不相等，采用邻接矩阵表示法存储表示。

利用BFS算法求其各连通分量，并输出各连通分量中的顶点。

 Input

有多组测试数据，每组数据的第一行为两个整数n和e，表示n个顶点和e条边（0

 Output

按存储顺序的先后，输出各连通分量中的顶点，每组输出占若干行，每行最后均无空格，每两组数据之间有一空行，具体格式见样例。

 SampleInput

44

ABCD

01

03

12

13

43

ABCD

01

03

13

 SampleOutput

1:

A,B,D,C

1:

A,B,D

2:

C

voidMGraph:

:

BFSTraverse（intv）

{

intQ[MaxSize];

intfront=rear=-1;//初始化队列

visited[v]=1;

Q[++rear]=v;

cout<

'<

while（front!

=rear）

{

v=Q[++front];//将队头元素出队并送到v中

for（intj=0;j

if（arc[v][j]==1&&visited[j]==0）

{

cout<<","<

visited[j]=1;

Q[++rear]=j;

}

}

cout<

}

intmain（）

{

intvexnum,edgenum,i,k;

charvex[MaxSize];

k=0;

while（cin>>vexnum>>edgenum）

{

cin>>vex;

MGraphg（vex,vexnum,edgenum）;

memset（visited,0,sizeof（visited））;

if（k）

cout<

k=1;

num=0;

for（i=0;i

if（visited[i]==0）

{

num++;

g.BFSTraverse（i）;

}

}

return0;

}

#include

usingnamespacestd;

intn,m;

charc[25];

inta[25][25];

intv[25];

intnum=0;

voidBFS（intk）

{

intrear=-1,front=-1,i;//记住输出，入队，标记

ints[25];

cout<

"<

s[++rear]=k;

v[k]=1;

while（front!

=rear）

{

intq=s[++front];

for（i=0;i

{

if（a[q][i]==1&&v[i]==0）

{

cout<<","<

v[i]=1;

s[++rear]=i;

}

}

}

cout<

}

intmain（）

{

intk;

inti,j;

intf=0;

while（cin>>n>>m）

{

if（f==1）

cout<

num=0;

cin>>c;

memset（a,0,sizeof（a））;

memset（v,0,sizeof（v））;

for（k=0;k

{

cin>>i>>j;

a[i][j]=1;

a[j][i]=1;

}