Floyd算法实践，包含跨楼层路线

本文链接

链接: https://blog.csdn.net/weixin_43603903/article/details/102728454.

代码片

class FloydPath():
    def __init__(self):
        # self.pathData = []
        pass


    def find_path(self,prior_matrix, i, j, addressString):
        '''
        :param prior_matrix: 记录从所有初始节点到终止节点的最短路径所需要经过的上一个节点
        :param i:当前的起始节点 i+1为真实节点编号
        :param j:当前的终止节点 +1为真实节点编号
        :return:返回最短路径所经过的节点
        '''
        if prior_matrix[i][j] == j:
            # return 'node_f1%d' % (i + 1) + '->' + 'node_f1%d' % (j + 1)
            return '%s' % addressString[i] + '->'+'%s' % addressString[j] + '/'

        else:
            return FloydPath().find_path(prior_matrix, i, prior_matrix[i][j], addressString) \
                   + FloydPath().find_path(prior_matrix, prior_matrix[i][j], j, addressString)


    def find_Stairs(self,addressString):
        #查询所有楼梯间
        stairs = []
        for i in range(len(addressString)):
            if addressString[i].find('楼梯') >= 0:
                stairs.append(i+1)
        return stairs

    def find_new_path(self,prior_matrix, i, j, addressString, distance_matrix, real):
        '''
        :param prior_matrix: 记录从所有初始节点到终止节点的最短路径所需要经过的上一个节点
        :param i:当前的起始节点 i+1为真实节点编号
        :param j:当前的终止节点 +1为真实节点编号
        :param addressString:所有转折点
        :param distance_matrix：任何一段路之间的距离
        :param real：Ture：正常的路线，False：去重复的楼梯
        :return:返回去重之后最短路径所经过的节点
        '''
        path = self.find_path(prior_matrix, i, j, addressString)
        if path.count('>') == 1:  # 如果从初始节点i到终止节点j并不需要任何的中间节点，则直接输出字符串
            display_line = path
            # print('\n')

            # print()
            # print(temp_route)
        else:
            # 此时 find_path 函数返回字符串具有中间的overlap，需要去重
            # print(temp_route)
            output_str = path.split('->')
            display_line = ''
            display_line += '%s' % (addressString[i])

            for t in range(1, len(output_str) - 1):
                # output_str[t] = output_str[t][0:int(len(output_str) / 2)]
                display_line += ',' + output_str[t][0:int(len(output_str[t]) / 2)]
            display_line += '->%s' % (addressString[j])
            # 两层路线合并去重
            # if real:
            #     display_line += '->%s' % (addressString[j])
            # else:
            #     display_line += ','

        return ['node%s->node%s: distance:%s' % (addressString[i], addressString[j], distance_matrix[i][j]),
              'route:', display_line]

    def find_stairs_path(self,stairs, addressString, distance_matrix, prior_matrix,i):
        for kay, vals in enumerate(stairs):
            vals -= 1
            c = FloydPath().find_path(prior_matrix, i, vals, addressString)
            # return '%s' % addressString_f1[i] + '->' + '%s' % addressString_f1[j] + '/'
#<<<可注释
            if c.count('>') == 1:  # 如果从初始节点i到终止节点j并不需要任何的中间节点，则直接输出字符串
                display_line = c
                # print('\n')

                # print()
                # print(temp_route)
            else:
                # 此时 find_path 函数返回字符串具有中间的overlap，需要去重
                # print(temp_route)
                output_str = c.split('->')
                display_line = ''
                display_line += '%s' % (addressString[i])

                for t in range(1, len(output_str) - 1):
                    # output_str[t] = output_str[t][0:int(len(output_str) / 2)]
                    display_line += '->' + output_str[t][0:int(len(output_str[t]) / 2)]
                display_line += '->%s' % (addressString[vals])
#可注释>>>

            if pathData:
                # 两层之间通过不同楼梯间所走的距离
                lens_data = []
                for u in range(len(pathData)):
                    lens_data.append(pathData[u][0