在有100个点的散点图中，已知各点的编号、坐标以及部分点之间连接路径长度，在这100个点当中选择三个目标点，求解其余各点能够在给定的路径当中选择选择最短路径到达距离其最近的目标点的最短路径距离之和并求出三个目标点的坐标以及所用路径对应的端点的编号

这是一个经典的最近邻问题，可以使用最近邻算法来解决。以下是解决问题的步骤：

1. 对于每一个目标点，使用最近邻算法找到距离其最近的点，并记录下最短路径距离和对应的端点编号。
2. 对于剩余的点，使用最近邻算法找到离其最近的目标点，并记录下最短路径距离和对应的目标点编号。
3. 对于每一个目标点，将其最近的点与其他目标点的最近点之间的路径加入到路径列表中。
4. 对于三个目标点，找到路径列表中路径长度之和最小的路径组合，即为对应的路径和端点编号。

下面是实现代码，假设目标点的坐标和编号存储在字典target_dict中，连接路径长度存储在字典path_dict中，坐标和编号存储在字典coord_dict中：

import math

# 计算两点之间的欧几里得距离
def distance(coord1, coord2):
    return math.sqrt((coord1[0] - coord2[0]) ** 2 + (coord1[1] - coord2[1]) ** 2)

# 使用最近邻算法查找距离最近的点
def nearest_neighbor(coord, coord_dict):
    min_dist = float('inf')
    nearest_coord = None
    for key, value in coord_dict.items():
        if key != coord and distance(coord, value) < min_dist:
            min_dist = distance(coord, value)
            nearest_coord = key
    return nearest_coord, min_dist

# 查找距离最近的目标点
def nearest_target(coord, target_dict):
    min_dist = float('inf')
    target_id = None
    for key, value in target_dict.items():
        if distance(coord, value) < min_dist:
            min_dist = distance(coord, value)
            target_id = key
    return target_id, min_dist

# 查找距离目标点最近的点
def nearest_point(target_id, coord_dict):
    min_dist = float('inf')
    nearest_coord = None
    for key, value in coord_dict.items():
        if key != target_id and distance(value, target_dict[target_id]) < min_dist:
            min_dist = distance(value, target_dict[target_id])
            nearest_coord = key
    return nearest_coord, min_dist

# 计算路径长度
def path_length(path, coord_dict):
    length = 0
    for i in range(len(path) - 1):
        length += distance(coord_dict[path[i]], coord_dict[path[i+1]])
    return length

# 查找距离最近的目标点和路径长度
def nearest_target_and_path(coord, target_dict, path_dict):
    min_dist = float('inf')
    target_id = None
    path_length_min = float('inf')
    for key, value in target_dict.items():
        dist = distance(coord, value)
        if dist < min_dist:
            min_dist = dist
            target_id = key
            path_length_min = path_dict[(coord, value)]
    return target_id, path_length_min

# 查找路径最短的三个目标点组合
def find_shortest_path_combination(target_dict, path_dict):
    shortest_length = float('inf')
    shortest_combination = None
    for i in range(100):
        for j in range(i+1, 100):
            for k in range(j+1, 100):
                path1 = [i, nearest_point(i, target_dict)[0], nearest_point(i, target_dict)[1], j, nearest_point(j, target_dict)[0], nearest_point(j, target_dict)[1], k, nearest_point(k, target_dict)[0], nearest_point(k, target_dict)[1]]
                path2 = [j, nearest_point(j, target_dict)[0], nearest_point(j, target_dict)[1], i, nearest_point(i, target_dict)[0], nearest_point(i, target_dict)[1], k, nearest_point(k, target_dict)[0], nearest_point(k, target_dict)[1]]
                path3 = [k, nearest_point(k, target_dict)[0], nearest_point(k, target_dict)[1], i, nearest_point(i, target_dict)[0], nearest_point(i, target_dict)[1], j, nearest_point(j, target_dict)[0], nearest_point(j, target_dict)[1]]
                length = path_length(path1, coord_dict) + path_length(path2, coord_dict) + path_length(path3, coord_dict)
                if length < shortest_length:
                    shortest_length = length
                    shortest_combination = (path1, path2, path3)
    return shortest_combination

# 存储坐标和编号
coord_dict = {}
for i in range(100):
    coord_dict[i] = (x[i], y[i])

# 存储连接路径长度
path_dict = {}
for i in range(100):
    for j in range(i+1, 100):
        path_dict[(i, j)] = distance(coord_dict[i], coord_dict[j])

# 存储目标点
target_dict = {}
target_dict[1] = (x[0], y[0])
target_dict[2] = (x[1], y[1])
target_dict[3] = (x[2], y[2])

# 计算每个点到其最近的目标点的最短路径距离之和
total_length = 0
for i in range(100):
    if i not in target_dict.keys():
        target_id, path_length_min = nearest_target_and_path(coord_dict[i], target_dict, path_dict)
        total_length += path_length_min

# 查找路径最短的三个目标点组合
shortest_combination = find_shortest_path_combination(target_dict, path_dict)

# 输出结果
print("目标点坐标：")
for key, value in target_dict.items():
    print(key, value)
print("路径端点编号：")
for i in range(3):
    print(shortest_combination[i])
print("路径长度之和：")
print(path_length(shortest_combination[0], coord_dict) + path_length(shortest_combination[1], coord_dict) + path_length(shortest_combination[2], coord_dict))