一、图的定义
(1)顶点
顶点(也称为“节点”)是图的基本部分。它可以有一个名称,我们将称为“键”。
(2)边
边(也称为“弧”)是图的另一个基本部分。边连接两个顶点,以表明它们之间存在关系。
(3)权重
边可以被加权以示出从一个顶点到另一个顶点的成本。例如,在将一个城市连接到另一个城市的道路的图表中,边上的权重可以表示两个城市之间的距离。
利用这些定义,我们可以正式定义图。图可以由 G 表示,其中 G =(V,E)。对于图 G,V 是一组顶点,E 是一组边。每个边是一个元组 (v,w),其中 w,v ∈ V。我们可以添加第三个组件到边元组来表示权重。子图 s 是边 e 和顶点 v 的集合,使得 e⊂E 和 v⊂V 。
下图展示了简单加权有向图的另一示例。正式地,我们可以将该图表示为:
六个顶点的集合:
V={V0,V1,V2,V3,V4,V5};
9 条边的集合:
E={(v0,v1,5),(v1,v2,4),(v2,v3,9),(v3,v4,7),(v4,v0,1),(v0,v5,2),(v5,v4,8),(v3,v5,3),(v5,v2,1)}
二、常见的图结构
图的两种常用的表示方式是邻接矩阵和邻接表。
2.1 邻接矩阵
实现图的最简单的方法之一是使用二维矩阵。在该矩阵实现中,每个行和列表示图中的顶点。存储在行 v 和列 w 的交叉点处的单元中的值表示是否存在从顶点 v 到顶点 w 的边。 当两个顶点通过边连接时,我们说它们是相邻的。 下图展示了图的邻接矩阵。单元格中的值表示从顶点 v 到顶点 w 的边的权重。
邻接矩阵的优点是简单,对于小图,很容易看到哪些节点连接到其他节点。 然而,注意矩阵中的大多数单元格是空的。 因为大多数单元格是空的,我们说这个矩阵是“稀疏的”。矩阵不是一种非常有效的方式来存储稀疏数据。
2.2 邻接表
实现稀疏连接图的更空间高效的方法是使用邻接表。在邻接表实现中,我们保存 Graph 对象中的所有顶点的主列表,然后图中的每个顶点对象维护连接到的其他顶点的列表。 在我们的顶点类的实现中,我们将使用字典而不是列表,其中字典键是顶点,值是权重。
邻接表实现的优点是它允许我们紧凑地表示稀疏图。 邻接表还允许我们容易找到直接连接到特定顶点的所有链接。
三、python 实现图
在我们的 Graph 抽象数据类型的实现中,我们将创建两个类,Graph(保存顶点的主列表)和 Vertex(将表示图中的每个顶点)。每个顶点使用字典来跟踪它连接的顶点和每个边的权重。这个字典称 connectedTo 。
下面展示了 Vertex 类的代码。构造函数只是初始化 id ,通常是一个字符串和 connectedTo 字典。 addNeighbor 方法用于从这个顶点添加一个连接到另一个。getConnections 方法返回邻接表中的所有顶点,如 connectedTo 实例变量所示。 getWeight 方法返回从这个顶点到作为参数传递的顶点的边的权重。
class Vertex:
def __init__(self,key):
self.id=key
self.connectedTo={}
def addNeighbor(self,nbr,weight=0):
self.connectedTo[nbr]=weight
def getConnections(self):
return self.connectedTo.keys() #keys()将字典中的键以列表的形式返回
def getId(self):
return self.id
def getWeight(self,nbr):
return self.connectedTo[nbr]
def __str__(self): #当使用print输出对象的时候,只要自己定义了__str__(self)方法,那么就会打印从在这个方法中return的数据
return str(self.id) + ' connectedTo: ' + str([x.id for x in self.connectedTo])
下面展示了 Graph 类的代码,包含将顶点名称映射到顶点对象的字典。Graph 还提供了将顶点添加到图并将一个顶点连接到另一个顶点的方法。getVertex方法返回图中所有顶点的名称。此外,我们实现了__iter__ 方法,以便轻松地遍历特定图中的所有顶点对象。 这两种方法允许通过名称或对象本身在图形中的顶点上进行迭代。
class Graph:
def __init__(self):
self.vertList={}
self.numVertices=0
def addVertex(self,key):
self.numVertices+=1
newVertex=Vertex(key)
self.vertList[key]=newVertex
return newVertex
def getVertex(self,n):
if n in self.vertList:
return self.vertList[n]
else:
return None
def __contains__(self,n):
return n in self.vertList
def addEdge(self,f,t,cost=0):
if f not in self.vertList:
nv=self.addVertex(f)
if t not in self.vertList:
nv=self.addVertex(t)
self.vertList[f].addNeighbor(self.vertList[t],cost)
def getVertices(self):
return self.vertList.keys()
def __iter__(self): #如果一个类想被用于for ... in循环,类似list或tuple那样,就必须实现一个__iter__()方法,该方法返回一个迭代对象,然后,Python的for循环就会不断调用该迭代对象的next()方法拿到循环的下一个值,直到遇到StopIteration错误时退出循环。
return iter(self.vertList.values()) #values()方法以列表的形式返回字典中的值
我们用上面定义的两个类,建立如下的图结构。首先我们创建 6 个编号为 0 到 5 的顶点。然后我们展示顶点字典。注意,对于每个键 0 到 5,我们创建了一个顶点的实例。接下来,我们添加将顶点连接在一起的边。 最后,嵌套循环验证图中的每个边缘是否正确存储。
g = Graph()
for i in range(6):
g.addVertex(i)
g.addEdge(0,1,5)
g.addEdge(0,5,2)
g.addEdge(1,2,4)
g.addEdge(2,3,9)
g.addEdge(3,4,7)
g.addEdge(3,5,3)
g.addEdge(4,0,1)
g.addEdge(5,4,8)
g.addEdge(5,2,1)
print(g.vertList)
for v in g: #调用__iter__()方法
for w in v.getConnections():
print("( %s , %s )" % (v.getId(), w.getId()))
输出:
VertList:
{ 0: vertex(0), 1: vertex(1), 2: vertex(2), 3: vertex(3), 4: vertex(4), 5: vertex(5)}
vertex(0):
id=0
ConnectedTo={1:5,5:2}
vertex(1):
id=1
ConnectedTo={2:4}
vertex(2):
id=2
ConnectedTo={3:9}
vertex(3):
id=3
ConnectedTo={4:7,5:3}
vertex(4):
id=4
ConnectedTo={0:1}
vertex(5):
id=5
ConnectedTo={4:8,2:1}
四、图的搜索
回溯法(探索与回溯法)是一种选优搜索法,按选优条件向前搜索,以达到目标。但当探索到某一步时,发现原先选择并不优或达不到目标,就退回一步重新选择,这种走不通就退回再走的技术为回溯法,而满足回溯条件的某个状态的点称为“回溯点”。
4.1 广度优先搜索 (BFS)
它的思想是:从图中某顶点v出发,在访问了v之后依次访问v的各个未曾访问过的邻接点,然后分别从这些邻接点出发依次访问它们的邻接点,并使得“先被访问的顶点的邻接点先于后被访问的顶点的邻接点被访问,直至图中所有已被访问的顶点的邻接点都被访问到。如果此时图中尚有顶点未被访问,则需要另选一个未曾被访问过的顶点作为新的起始点,重复上述过程,直至图中所有顶点都被访问到为止。
实现步骤:
(1)顶点v入队列。
(2)当队列非空时则继续执行,否则算法结束。
(3)出队列取得队头顶点v;访问顶点v并标记顶点v已被访问。
(4)查找顶点v的第一个邻接顶点col。
(5)若v的邻接顶点col未被访问过的,则col入队列。
(6)继续查找顶点v的另一个新的邻接顶点col,转到步骤(5)。直到顶点v的所有未被访问过的邻接点处理完。转到步骤(2)。
描述
给一个
n x m
的矩阵,矩阵的值有0、1、2,0代表海,1
代表海岛,2
代表海岛上的城市(你可以看做2
是建立在1
的上面,即2
也也同时代表海岛)。
如果2
个1
相邻,那么这两个1
属于同一个岛。现在求至少有一个城市的海岛个数。
- 我们只考虑上下左右为相邻。
n <= 100,m <= 100
。- 你可以假设矩阵的四个边都被海包围。
样例
样例1
输入: [ [1,1,0,0,0], [0,1,0,0,1], [0,0,0,1,1], [0,0,0,0,0], [0,0,0,0,1] ] 输出: 0 解释: 有3个海岛,但是他们都不含有城市。
样例2
输入: [ [1,1,0,0,0], [0,1,0,0,1], [0,0,2,1,2], [0,0,0,0,0], [0,0,0,0,2] ] 输出: 2 解释: 有3个海岛,有2个海岛含有城市。
from collections import deque
def numIslandCities(self, grid):
que = deque()
ans = 0 #城市数目
n = len(grid) #矩阵行数
m = len(grid[0]) #矩阵列数
vis = [[0 for j in range(m)] for i in range(n)] #建立一个n行m列的空矩阵
dxy = [(0, 1), (0, -1), (1, 0), (-1, 0)]
for i in range(n):
for j in range(m):
if vis[i][j] == 1 or grid[i][j] == 0:
continue
que.append((i, j))
vis[i][j] = 1
city = False
while len(que) > 0:
x, y = que.popleft() #队列先进先出
if grid[x][y] == 2:
city = True
for incx, incy in dxy:
tx = x + incx
ty = y + incy
if tx < 0 or tx >= n or ty < 0 or ty >= m or \
vis[tx][ty] == 1 or grid[tx][ty] == 0:
continue
vis[tx][ty] = 1
que.append((tx, ty))
if city:
ans = ans + 1
return ans
4.2 深度优先搜索(DFS)
它的思想:假设初始状态是图中所有顶点均未被访问,则从某个顶点v出发,首先访问该顶点,然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图,直至图中所有和v有路径相通的顶点都被访问到。 若此时尚有其他顶点未被访问到,则另选一个未被访问的顶点作起始点,重复上述过程,直至图中所有顶点都被访问到为止。显然,深度优先搜索是一个递归的过程。
实现步骤:
(1)访问初始顶点v并标记顶点v已访问。
(2)查找顶点v的第一个邻接顶点w。
(3)若顶点v的邻接顶点w存在,则继续执行;否则回溯到v,再找v的另外一个未访问过的邻接点。
(4)若顶点w尚未被访问,则访问顶点w并标记顶点w为已访问。
(5)继续查找顶点w的下一个邻接顶点wi,如果v取值wi转到步骤(3)。直到连通图中所有顶点全部访问过为止。
问题描述:
问题分析:
题目:根据城堡地形图,计算城堡一共多少间房间,最大房间有多大
城堡被分成m*n个方块,每个方块可以有0~4面墙
输入要求:第一行输入m,n
接下来的输入行中,每个方块用数字描述,表示方块周围的墙
其中,1代表西墙;2代表北墙;4代表东墙;8代表南墙
若第一个方块是11,(其二进制数为1011(对应:西北东南;1代表有墙,0代表无墙))
输入时至少保证有两个房间
输出要求:
输出城堡房间数及最大房间的方块数
"""
#输入方块的行数n和列数m
RC=input("请输入方块的行数和列数:").split(' ')
RC = list(map(int, RC))
n=RC[0]
m=RC[1]
rooms=[[0 for i in range(m)] for j in range(n)]
color=[[0 for i in range(m)] for j in range(n)]
for i in range(n):
rooms[i]=input("请输入第"+str(i+1)+"行数值:").split(' ')
#将rooms中的元素转换为整型
rooms[i] = list(map(int, rooms[i]))
roomnum=0
maxRoomArea=0
def Dfs(i,j):
global roomnum
global roomArea
if color[i][j]!=0:
return
roomArea+=1
color[i][j]=roomnum
if rooms[i][j]&1==0: #向西走
Dfs(i,j-1)
if rooms[i][j]&2==0: #向北走
Dfs(i-1,j)
if rooms[i][j]&4==0: #向东走
Dfs(i,j+1)
if rooms[i][j]&8==0: #向南走
Dfs(i+1,j)
for i in range(n):
for j in range(m):
if color[i][j]==0:
roomnum+=1
roomArea=0
Dfs(i,j)
maxRoomArea=max(roomArea,maxRoomArea)
print("房间数量:",roomnum)
print("最大房间的方块数:",maxRoomArea)
print(color)