LeetCode：1631.最小体力消耗路径——中等

题目：
1631.最小体力消耗路径

你准备参加一场远足活动。给你一个二维 rows x columns 的地图 heights ，其中 heights [ row ][ col ] 表示格子 ( row, col ) 的高度。一开始你在最左上角的格子 (0, 0) ，且你希望去最右下角的格子 (rows-1, columns-1) （注意下标从 0 开始编号）。你每次可以往 上，下，左，右 四个方向之一移动，你想要找到耗费 体力 最小的一条路径。

一条路径耗费的 体力值 是路径上相邻格子之间 高度差绝对值 的 最大值 决定的。

请你返回从左上角走到右下角的最小 体力消耗值 。

示例 1：

输入：heights = [[1,2,2],[3,8,2],[5,3,5]]
输出：2
解释：路径 [1,3,5,3,5] 连续格子的差值绝对值最大为 2 。
这条路径比路径 [1,2,2,2,5] 更优，因为另一条路径差值最大值为 3 。

示例 2：

输入：heights = [[1,2,3],[3,8,4],[5,3,5]]
输出：1
解释：路径 [1,2,3,4,5] 的相邻格子差值绝对值最大为 1 ，比路径 [1,3,5,3,5] 更优。

示例 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
解释：上图所示路径不需要消耗任何体力。

提示：

• rows == heights.length
• columns == heights[i].length
• 1 <= rows, columns <= 100
• 1 <= heights[i][j] <= 106

解题思路：
根据二维数组，以每一个点为基础初始化并查集p，然后建立边的集合edges，记录相邻位置的两点（下，左）及其绝对值差，对在edges的边，合并并查集，记录最大cost。当p[0]与p[-1]连通是，返回cost

代码：

class Solution:
    def minimumEffortPath(self, heights: List[List[int]]) -> int:
    	# 当数组仅有第一个元素时
        if len(heights) < 2 and len(heights[0]) < 2:
            return 0
        
        
		# 当数组只有一行时
        if len(heights) == 1:
            cost = 0
            for j in range(1, len(heights[0])):
                cost = max(cost, abs(heights[0][j] - heights[0][j-1]))
            return cost
        
		# 当数组只有一列时
        if len(heights[0]) == 1:
            cost = 0
            for i in range(1, len(heights)):
                cost = max(cost, abs(heights[i][0] - heights[i-1][0]))
            return cost


		# 初始化并查集
        num = len(heights) * len(heights[0])
        p = [[i] for i in range(num)]
        edges = []


		# 对每个元素，对左边、下班元素，建立边的集合，形式为[x, y, gap]
        for i in range(len(heights)):
            for j in range(len(heights[0])):
                pointX = i * len(heights[0]) + j
                if j <= len(heights[0]) - 2:
                    pointY = i * len(heights[0]) + j + 1
                    gap = abs(heights[i][j] - heights[i][j+1])
                    edges.append([pointX, pointY, gap])
                if i <= len(heights) - 2:
                    pointY = (i+1) * len(heights[0]) + j
                    gap = abs(heights[i][j] - heights[i+1][j])
                    edges.append([pointX, pointY, gap])
        
        
		# 并查集的合并操作
        cost = 0
        edges.sort(key = lambda x:x[-1])
        for edge in edges:
            if p[0] is p[-1]:
                return cost
            else:
                x, y, gap = edge
                if p[x] is not p[y]:
                    cost = max(gap, cost)
                    p[x].extend(p[y])
                    for z in p[x]:
                        p[z] = p[x]

提交记录：

然后昨天刚学了一下Kruskal算法，不过还不是很懂，就跟着别人的题解敲了一遍（手动黑脸）

class UnionFindSet:
    def __init__(self, elements):
        self.father = {}
        self.rank = {}
        for element in elements:
            self.father[element] = element
            self.rank[element] = 1
    

    def find_head(self, element):
        stack = []
        while element != self.father[element]:
            stack.append(element)
            element = self.father[element]
        while stack:
            self.father[stack.pop()] = element
        return element
    

    def union(self, element1, element2):
        head1 = self.find_head(element1)
        head2 = self.find_head(element2)
        if head1 == head2:
            return
        if self.rank[head1] < self.rank[head2]:
            head1, head2 = head2, head1
        self.rank[head1] += self.rank[head2]
        self.rank.pop(head2)
        self.father[head2] = head1

    
    def is_name_set(self, element1, element2):
        head1 = self.find_head(element1)
        head2 = self.find_head(element2)
        if head1 == head2:
            return True
        else:
            return False


class Solution:
    def minimumEffortPath(self, heights: List[List[int]]) -> int:
        if not len(heights) or not len(heights[0]):
            return 0
        

        elements = [(i, j) for i in range(len(heights)) for j in range(len(heights[0]))]
        edges = []
        for i in range(len(heights)):
            for j in range(len(heights[0])):
                if i > 0:
                    edge = [abs(heights[i][j] - heights[i-1][j]), (i, j), (i-1, j)]
                    edges.append(edge)
                if i < len(heights) - 1:
                    edge = [abs(heights[i][j] - heights[i+1][j]), (i, j), (i+1, j)]
                    edges.append(edge)
                if j > 0:
                    edge = [abs(heights[i][j] - heights[i][j-1]), (i, j), (i, j-1)]
                    edges.append(edge)
                if j < len(heights[0]) - 1:
                    edge = [abs(heights[i][j] - heights[i][j+1]), (i, j), (i, j+1)]
                    edges.append(edge)
        ufs = UnionFindSet(elements)
        edges.sort()
        start = (0, 0)
        end = (len(heights)-1, len(heights[0])-1)
        ret = 0
        for weight, v1, v2 in edges:
            if ufs.is_name_set(start, end):
                return ret
            if ufs.is_name_set(v1, v2):
                pass
            else:
                ufs.union(v1, v2)
                ret = weight
        return ret