1144 连接格点（kruskal算法-创建所有相邻边的技巧）

本文主要是介绍1144 连接格点（kruskal算法-创建所有相邻边的技巧），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1. 问题描述：

2. 思路分析：

3. 代码如下：

import sys
from typing import List


class Solution:
    def getEdges(self, n: int, m: int, fa: List[int], mp: List[List[int]]):
        # 下标为0,2属于建立竖的边, 1, 3属于横的边, 坐标与权重要一一对应
        dx = [-1, 0, 1, 0]
        dy = [0, -1, 0, 1]
        # 边的权重
        dw = [1, 2, 1, 2]
        w = list()
        # 最外面循环是用来控制创建竖的边和横的边的顺序, z = 0时建立所有竖边, z = 1时建立所有横边, 这样自然避免了对边权排序的步骤, 降低时间复杂度
        for z in range(0, 2):
            for i in range(1, n + 1):
                for j in range(1, m + 1):
                    for u in range(4):
                        if u % 2 == z:
                            x, y, t = i + dx[u], j + dy[u], dw[u]
                            if 1 <= x <= n and 1 <= y <= m:
                                a, b = mp[i][j], mp[x][y]
                                # 只有当a < b的时候才建边, 说明是向右边延伸或者是向下边延伸
                                if a < b:
                                    w.append((mp[i][j], mp[x][y], t))
        return w

    # 并查集查找x的父节点并路径压缩
    def find(self, x: int, fa: List[int]):
        if x != fa[x]:
            fa[x] = self.find(fa[x], fa)
        return fa[x]

    # 这里使用到的一个技巧是先创建权重为1的边然后再创建权重为2的边
    def process(self):
        n, m = map(int, input().split())
        mp = [[0] * (m + 1) for i in range(n + 1)]
        count = 0
        # 建立二维坐标与一维坐标的映射
        for i in range(1, n + 1):
            for j in range(1, m + 1):
                mp[i][j] = count
                count += 1
        fa = [i for i in range(n * m + 10)]
        while True:
            t = sys.stdin.readline().strip()
            if not t: break
            # 表示两个点具有联系, 表示必须需要选择的边
            x1, y1, x2, y2 = map(int, t.split())
            a, b = self.find(mp[x1][y1], fa), self.find(mp[x2][y2], fa)
            if a != b:
                fa[a] = b
        # 创建竖的边和横的边
        w = self.getEdges(n, m, fa, mp)
        res = 0
        # kruskal算法有一个好处是在合并前先判断是否属于同一个集合, 所以之前的无脑加入所有的边也是正确的, 可以减少一些判断的代码, 下面只需要判断两个点是否属于同一个集合即可判断之前是否加入过边
        for x in w:
            a, b = self.find(x[0], fa), self.find(x[1], fa)
            if a != b:
                res += x[2]
                fa[a] = b
        return res


if __name__ == "__main__":
    print(Solution().process())

这篇关于1144 连接格点（kruskal算法-创建所有相邻边的技巧）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！