#从其中的某一城市出发，不重复地走完其余5个并回到原出发点，在所有可能的路径中求出路径长度最短的一条。

六个市坐标为：1(87,7).2(91,38)、3(83,46).4(71,44).5(64,60)、6(68,58)

import math
city={'x':[87,91,83,71,64,68],'y':[7,38,46,44,60,58]}
n=6
x=city['x']
y=city['y']
import numpy as np
#计算距离
a=np.zeros((n,n))
for i in range(6):
for j in range(6):
a[i,j] = math.sqrt(pow(x[i]-x[j],2)+pow(y[i]-y[j],2))
#生成6个城市的全部排列
import itertools
v=list(itertools.permutations([1,2,3,4,5,6],n))
#计算最短总距离
m=len(v)
juli=[]
for i in range(m):
sum=0
for j in range(n-1):
sum=sum+a[v[i][j]-1,v[i][j+1]-1]
sum=sum+a[v[i][j+1]-1,v[i][0]-1]
juli.append(sum)
print('最小距离：',min(juli))
zuiyou=min(juli)
c=juli.index(min(juli))
print('最短路径：',v[c])
原问题采用先生成全部可能结果的排列，存下来，在比较的方法；
如何修改为不依赖存储的排列结果，换句话说，一个一个比较，算一个，比较一个的方法呢？

import math

city = {'x': [87, 91, 83, 71, 64, 68], 'y': [7, 38, 46, 44, 60, 58]}
n = 6
x = city['x']
y = city['y']
import numpy as np

# 计算距离
a = np.zeros((n, n))
for i in range(6):
    for j in range(6):
        a[i, j] = math.sqrt(pow(x[i] - x[j], 2) + pow(y[i] - y[j], 2))
# 生成6个城市的全部排列
import itertools

v = list(itertools.permutations([1, 2, 3, 4, 5, 6], n))
# 计算最短总距离
m = len(v)
juli = []
min_sum = "inf"  # ==========================================================初始化min_sum为正无穷
for i in range(m):
    sum = 0
    
    for j in range(n - 1):
        sum = sum + a[v[i][j] - 1, v[i][j + 1] - 1]
        sum = sum + a[v[i][j + 1] - 1, v[i][0] - 1]
        """
        if sum < min_sum:
            min_sum = sun =========================================== 在计算出结果后，前一个结果和后一个结果直接比较
        """
    juli.append(sum)
print('最小距离：', min(juli))
zuiyou = min(juli)   # ==========================================这行可以注释
c = juli.index(min(juli))
print('最短路径：', v[c])
# 原问题采用先生成全部可能结果的排列，存下来，在比较的方法；
# 如何修改为不依赖存储的排列结果，换句话说，一个一个比较，算一个，比较一个的方法呢？

你原来的问题好像没有计算出发的城市，如果从1出发，最后还要回到1，所以还要加上最后一个城市回到1的距离。
如果不用全排列组合，可以用深搜，计算路径的过程中，如果比最短路径要长，就剪枝返回，如果比最短路径短，就更新最短路径：

def dfs(cities,path,dist):
    global shortest,best_path
    if len(cities)==0:
        dist += a[path[-1]][path[0]]
        if dist<shortest:
            shortest=dist
            best_path=path+[path[0]]
    else:
        for i in range(len(cities)):
            temp = dist+a[path[-1]][cities[i]] if path else 0
            if temp>=shortest: continue
            else: dfs(cities[:i]+cities[i+1:],path+[cities[i]],temp)

shortest = math.inf
best_path = []
cities=list(range(6))
dfs(cities,list(),0)
print(shortest)
print([i+1 for i in best_path])

最短距离和路径为：

124.02775432052417
[3, 2, 1, 4, 5, 6, 3]