从探索到精通：图和并查集知识点全面解读

后端

2024-01-30 09:38:34

算法简介

图论

图论是一门研究图结构和图算法的数学分支。图由顶点（或节点）和边（或弧）组成，顶点表示实体，边表示顶点之间的关系。图论在计算机科学、网络理论、运筹学等领域有着广泛的应用。

并查集

并查集是一种数据结构，用于处理不相交集合的合并和查找操作。并查集通常用树形结构来表示，其中每个集合对应一个连通分量。并查集在算法设计和数据结构中有着广泛的应用，例如，用于求解最小生成树、最短路径问题等。

题目解析

leetcode 1631. Path With Minimum Effort（python）题目如下：

给你一个 m x n 的矩阵 heights ，其中 heights[i][j] 表示在 (i, j) 处的高度。
一个机器人从 (0, 0) 出发，想要到达 (m-1, n-1) 。机器人只能在相邻的四个方向移动，且每次移动，机器人都会疲劳，疲劳值等于它经过的路径中高度差的绝对值。
请你返回机器人能够到达 (m-1, n-1) 的最小疲劳值。

示例 1：
输入：heights = [[1,2,2],[3,8,2],[5,3,5]]
输出：2
解释：路径 (0, 0) -> (0, 1) -> (0, 2) -> (1, 2) -> (2, 2) -> (2, 1) -> (2, 0) -> (1, 0) -> (0, 0)
    该路径的最小疲劳值为：2 + 0 + 3 + 1 + 0 + 1 + 2 + 2 + 1 = 12

示例 2：
输入：heights = [[1,2,3],[3,8,4],[5,3,5]]
输出：1

示例 3：
输入：heights = [[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]
输出：0

为了解决此题，我们需要用到图论和并查集的相关知识。

算法实现

图的构建

首先，我们将给定的矩阵转换为图结构。矩阵中的每个元素对应图中的一个顶点，相邻的元素之间存在一条边。边的权重等于两个顶点的高度差的绝对值。

并查集的初始化

接下来，我们需要初始化并查集。并查集的每个元素对应图中的一个连通分量。我们将矩阵中的每个元素初始化为一个独立的连通分量。

边排序

接下来，我们需要将图中的所有边按权重从小到大进行排序。

并查集合并

现在，我们可以开始合并并查集中的连通分量了。我们将从权重最小的边开始，如果边的两个顶点属于不同的连通分量，则将这两个连通分量合并成一个连通分量。

最小疲劳值计算

当所有边都被处理完后，我们将得到一个包含所有连通分量的并查集。我们只需要找到包含(0, 0)和(m-1, n-1)的连通分量，那么这个连通分量的最小边权值就是机器人从(0, 0)到达(m-1, n-1)的最小疲劳值。

代码实现

def minimumEffortPath(heights):
    # 图的构建
    m, n = len(heights), len(heights[0])
    edges = []
    for i in range(m):
        for j in range(n):
            if i > 0:
                edges.append(((i-1, j), (i, j), abs(heights[i][j] - heights[i-1][j])))
            if j > 0:
                edges.append(((i, j-1), (i, j), abs(heights[i][j] - heights[i][j-1])))

    # 并查集的初始化
    parent = [i for i in range(m * n)]

    # 边排序
    edges.sort(key=lambda edge: edge[2])

    # 并查集合并
    def find(x):
        if parent[x] != x:
            parent[x] = find(parent[x])
        return parent[x]

    def union(x, y):
        px, py = find(x), find(y)
        if px != py:
            parent[px] = py

    # 最小疲劳值计算
    for edge in edges:
        x, y, weight = edge
        union(x, y)
        if find(0) == find(m * n - 1):
            return weight

    return -1

# 测试
heights = [[1,2,2],[3,8,2],[5,3,5]]
print(minimumEffortPath(heights))  # 2

heights = [[1,2,3],[3,8,4],[5,3,5]]
print(minimumEffortPath(heights))  # 1

heights = [[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]
print(minimumEffortPath(heights))  # 0