一道算法题，输入形如"a-b,b-c,b-d"的字符串，表示a点到b点（b到c、b到d）相邻且有路，假定没有形成环状，要求输出最远路径的数值，
比如：输入"a-b,b-c,b-d"时，输出应该为2，因为最远路径为"a-b-c"或"a-b-d"或其他，最远经过2段路。还比如：
输入（邻近点的路径）："b-e,b-c,c-d,a-b,e-f"
输出（最远的距离数）：4
代码思路：
1、先处理输入数据，得到全部邻近路径和全部点；
2、构造函数，可搜寻出某点的全部一阶路径；
3、构造函数，可搜寻出某点的全部二阶路径；
4、根据二阶路径函数，得到思路，构造出“给定某点的n阶路径，搜寻全部n+1阶路径”的函数；
5、设置死循环，得到某点的最高阶路径；
6、选出所有点中的最远的路径，输出。
代码如下：
def FarthestNodes(strPath: str):
path_list = strPath.replace('-', '').split(',') # ['ab', 'bc', 'bd']
# print('path_list:',path_list)
# 全部的点
node_list = list(set(''.join(path_list))) # ['c', 'a', 'd', 'b']
node_list.sort() # ['a', 'b', 'c', 'd']
# print('node_list:',node_list)
# 搜寻某点的全部一阶路径
def search_degree1_path(node: str):
node_degree1_list = []
for path in path_list:
if node in path:
if node == path[1]:
path = path[1] + path[0]
node_degree1_list.append(path)
return node_degree1_list
# node0_degree1_list = search_degree1_path(node_list[3])
# print('node_degree1_list',node0_degree1_list)
# 搜寻某点的全部二阶路径
def search_degree2_path(node: str):
degree1_path_list = search_degree1_path(node)
degree2_path_list = []
for path in degree1_path_list:
# 以一阶路径为基础，搜索延续点（第二个点）的全部一阶路径，也就是原点（第一个点）的二阶路径
second_degree1_list = search_degree1_path(path[-1])
# 删除包含原点的路径，即只保留去往第三点的路径
second_degree1_list_simple = [p for p in second_degree1_list if path[-2] not in p]
# 原点到本延续点的全部二阶路径
degree2_path_part_list = [path[:-1] + p for p in second_degree1_list_simple]
# 全部延续点的路径加到一起，形成原点的全部二阶路径
degree2_path_list.extend(degree2_path_part_list)
return degree2_path_list
# node0_degree2_list = search_degree2_path(node_list[3])
# print('node_degree2_list',node0_degree2_list)
# 给定某点的n阶路径，搜寻全部n+1阶路径；举例：已知2阶路径，求3阶路径；根据二阶路径函数修改而得
def search_degree_higher_path(node_degree_list: list):
degree_higher_path_list = []
for path in node_degree_list:
# 以n阶路径为基础，搜索第n+1个点的全部一阶路径，举例：以2阶路径为基础，搜索第3个点的一阶路径
second_degree1_list = search_degree1_path(path[-1])
# 删除包含上一阶节点（第n个点）的路径，举例：以2阶路径为基础，删除返回第2个点的路径
second_degree1_list_simple = [p for p in second_degree1_list if path[-2] not in p]
# 原有n阶路径+本节点下全部一阶路径，得到本节点下全部n+1阶路径
degree_higher_path_part_list = [path[:-1] + p for p in second_degree1_list_simple]
# 全部节点的路径加到一起，形成原点的全部n+1阶路径
degree_higher_path_list.extend(degree_higher_path_part_list)
return degree_higher_path_list
for node in node_list:
node_degree_list = search_degree1_path(node)
node_highest_degree_list = node_degree_list
length = 1
farthest_length = 1
farthest_path = node_highest_degree_list
while True:
node_degree_higher_list = search_degree_higher_path(node_degree_list)
if node_degree_higher_list:
node_highest_degree_list = node_degree_higher_list
length += 1
else:
break
node_degree_list = node_degree_higher_list
# print(f'node {node} highest_degree_path_list:',node_highest_degree_list)
# print(f'node {node} length:',length)
if length > farthest_length:
farthest_length = length
farthest_path = node_highest_degree_list
# print('farthest_length:', farthest_length)
# print('one of farthest_path:', farthest_path)
return farthest_length,farthest_path
if __name__ == '__main__':
# 输入相邻路径，得到最远路径
input_path = "b-e,b-c,c-d,a-b,e-f"
farthest_length,farthest_path = FarthestNodes(input_path)
print('farthest_length:', farthest_length)
print('one of farthest_path:', farthest_path)
