Question

我在很多不同的地方偷了钻石。这些地点位于坐标系（x，y）上，其中每个地点都以数字命名，并具有d时间，例如：

Name  X  Y  dT
1   283 248 0
2   100 118 184
3   211 269 993
4   200 200 948
5   137 152 0
6   297 263 513
7   345 256 481
8   265 212 0
9   185 222 840 
10  214 180 1149
11  153 218 0
12  199 199 0
13  289 285 149
14  177 184 597
15  359 192 0
16  161 207 0
17  94  121 316
18  296 246 0
19  193 122 423
20  265 216 11

dT代表适当的时间，并且在每个地方都有它的时间，这是我们在小偷将藏身处移开之前需要取回钻石的固定时间。

起点始终为1。

我只需要参观所有地方一次，然后取回钻石，以使总延迟最小化。使用欧几里得距离四舍五入到最接近的整数来计算距离。每个位置的到达时间以距离+先前距离为单位计算。每个地点的延迟时间为到达时间，总延迟时间为地点之间的延迟时间之和。

如果警察可以在该地点的应有时间之前拿到钻石，则延迟等于0；否则，延迟等于到达时间与该地点的预定时间之差。

我的任务是找到正确的顺序，使警察一次可以访问每个地方，从而最大程度地减少两个较大事件的延迟。

我想我自己已经很接近答案了，但是我很想知道您将如何解决它，并希望更好地理解其背后的数学，以便能够对其进行更好的编程。

这是我计算所有内容的代码，唯一缺少的是找到正确顺序的方法：

#------------------------------------------------------------------------

poss=[(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20)] # the order

here=[]
for p in range(len(poss)):
    tempos=[]
    for o in range(len(index)):
        point=poss[p][o]
        valuez=order[point-1]
        tempos.append(valuez)
    here.append(tempos)

#//DUE//

due =[[item[b][3] for b in range(len(index))] for item in here]

#//DISTANCE//

x_ = [[item[b][1] for b in range(len(index))] for item in here]
y_ = [[item[b][2] for b in range(len(index))] for item in here]
z = [list(zip(x_[a],y_[a])) for a in range(len(x_))]

dis = []
for aa in range(len(poss)) :
    tempor=[]
    for i in range(len(index)-1):
        firstpoint = z[aa][i]
        secondpoint = z[aa][i+1]
        distance = round(np.linalg.norm(np.array(secondpoint)-np.array(firstpoint)))
        distance = int(distance)
        tempor.append(distance)
    dis.append(tempor)


#//ARRIVAL TIME//
#Arrival time is the sum of the pv distance.

arrival = []
for v in range(len(poss)):
    forone = [0,dis[v][0],]
    for r in range(len(index)-2):
        sumz = dis[v][r+1] + forone[r+1]
        sumz = int(sumz)
        forone.append(sumz)
    arrival.append(forone)

#//DELAY//

delay=[]
for d in range(len(poss)) :
    tempo=[]
    for q in range(len(index)):
        v=arrival[d][q]-due[d][q]
        if arrival[d][q] <= due[d][q]:
            tempo.append(0)
        else :
            tempo.append(v)
    delay.append(tempo)

#//ORDER//
#goal is to find the right order that minimizes the delay for two larger instances.

total = [sum(x) for x in delay]
small= min(total)
final=here[total.index(small)]

print(small)

Answer 1

您可以通过添加travelling salesman problem来解决此问题，但是需要进行简单的修改。在TSP中，移至下一个位置的成本只是其与当前位置的距离。在您的算法中，费用计算如下：

if current_travelling_time < dT then
    cost = 0
else
    cost = dT - current_travelling_time

每条路径的总成本是通过将其总成本计算得出的。成本最低的路径就是您想要的路径。

解决这个问题的方法很简单，只需计算位置的所有排列（第一个位置除外）的成本即可。

请注意，这在计算上非常昂贵，因此您应该考虑动态编程。

有关这种蛮力方法，请参见https://codereview.stackexchange.com/questions/110221/tsp-brute-force-optimization-in-python。正如我已经提到的，成本需要进行不同的计算。

挑战：TSP问题并找到正确的最小化积分顺序

1 个答案: