MOOC数据结构与算法Python版-第十一周编程作业

1 找到小镇的法官（10分）

题目内容：

在一个小镇里，按从 1 到 N 标记了 N 个人。传言称，这些人中有一个是小镇上的秘密法官。

 

如果小镇的法官真的存在，那么：

1. 小镇的法官不相信任何人。

2. 每个人（除了小镇法官外）都信任小镇的法官。

3. 只有一个人同时满足属性 1 和属性 2 。

 

给定列表 trust，该列表由信任对 trust[i] = [a, b] 组成，表示标记为 a 的人信任标记为 b 的人。

如果小镇存在秘密法官并且可以确定他的身份，请返回该法官的标记。否则，返回 -1。

 

输入格式:

输入包含两行，第一行为一个正整数N，第二行为信任对列表trust，以合法的Python表达式给出

 

输出格式：

一个整数，表示法官的编号

 

输入样例：

4

[[1,3],[1,4],[2,3],[2,4],[4,3]]

 

输出样例：

3

 

参考代码模板：

 

1. def findJudge(N,trust):
2.     # code here
3.     pass
4.  
5. N = int(input())
6. trust = eval(input())
7. print(findJudge(N, trust))

程序代码：

def findJudge(N, trust):
    count = [0] * (N + 1)
    for i, j in trust:
        count[i] -= 1
        count[j] += 1
    for i in range(1, N + 1):
        if count[i] == N - 1:
            return i
    return -1


N = int(input())
trust = eval(input())
print(findJudge(N, trust))

2 远离大陆（10分）

题目内容：

你现在手里有一份大小为 M x N 的『地图』（网格） grid，上面的每个『区域』（单元格）都用 0 和 1 标记好了。其中 0 代表海洋，1 代表陆地

对于每个海洋方格，其存在一个距离它最近的陆地方格，相应有一个到陆地的最小距离

请输出上述所有最小距离中的最大值。

 

我们这里说的距离是『曼哈顿距离』（ Manhattan Distance）：(x0, y0) 和 (x1, y1) 这两个区域之间的距离是 |x0 - x1| + |y0 - y1| 。

 

如果地图上只有陆地或者海洋，请返回 -1。

 

输入格式:

输入共1行，为一个仅包含0与1的嵌套列表，用合法的Python表达式给出

 

输出格式：

一个整数，表示最短距离

 

输入样例：

[[1,0,1],[0,0,0],[1,0,1]]

 

输出样例：

2

注：最远的海洋区域坐标为(1,1)

 

参考代码模板：

 

1. def maxDistance(grid):
2.     # code here
3.     pass
4.  
5. grid=eval(input())
6. print(maxDistance(grid))

程序代码1：

def maxDistance(grid):
    # 地图规模
    n, m = len(grid), len(grid[0])
    # 每个点到陆地的曼哈顿距离
    dist = [[float('inf') for _ in range(m)] for _ in range(n)]
    # 该点是否被访问过
    visited = [[False for _ in range(m)] for _ in range(n)]
    # 队列
    q = []
    # 陆地计数
    cnt = 0
    ans = 0
    tot = n * m
    for i in range(n):
        for j in range(m):
            if grid[i][j]:
                dist[i][j] = 0
                visited[i][j] = True
                q.append((i, j))
                cnt += 1
    # 如果都是陆地或者都是海洋，则返回-1
    if cnt == tot or cnt == 0:
        return -1
    while q:
        x, y = q.pop(0) # 出列
        for i, j in [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)]:
            # 如果坐标合法并且没被访问过
            if 0 <= i < n and 0 <= j < m and not visited[i][j]:
                dist[i][j] = min(dist[i][j], dist[x][y] + 1) # 取最小值
                ans = max(ans, dist[i][j]) # 更新答案
                visited[i][j] = True
                q.append((i, j)) # 入列
    return ans


grid = eval(input())
print(maxDistance(grid))

3 钥匙和房间（10分）

题目内容：

有 N 个房间，开始时你位于 0 号房间。每个房间有不同的号码：0，1，2，...，N-1，并且房间里可能有一些钥匙能使你进入下一个房间。

 

在形式上，对于每个房间 i 都有一个钥匙列表 rooms[i]，每个钥匙 rooms[i][j] 由 [0,1，...，N-1] 中的一个整数表示，其中 N = rooms.length。 钥匙 rooms[i][j] = v 可以打开编号为 v 的房间。

 

最初，除 0 号房间外的其余所有房间都被锁住。

你可以自由地在房间之间来回走动。

请判断是否可以最终打开所有房间。

 

输入格式:

一行嵌套列表，列表长度为N，以合法的Python表达式格式给出

 

输出格式：

True或False，代表是否可以进入每个房间

 

输入样例：

[[1],[2],[3],[]]

 

输出样例：

True

 

参考代码模板：

 

1. def canVisitAll(rooms):
2.     # code here
3.     pass
4.  
5. rooms = eval(input())
6. print(canVisitAll(rooms))

程序代码1：

#深度优先
def canVisitAll(rooms):
    room_map = {0} 
    def enterroom(keys):
        for key in keys:
            if key not in room_map:
                room_map.add(key)
                enterroom(rooms[key])
            else:
                pass
        return
    enterroom(rooms[0])
    return len(room_map)==len(rooms)


rooms = eval(input())
print(canVisitAll(rooms))

程序代码2：

# 广度优先
def canVisitAll(rooms):
    visited, queue = {0}, [0]
    while queue:
        room_index = queue.pop()
        for key in rooms[room_index]:
            if key not in visited:
                visited.add(key)
                queue.insert(0,key)
    return len(visited) == len(rooms)

rooms = eval(input())
print(canVisitAll(rooms))