如何解决查找最便宜的路线转弯花费500，直走花费100-运行时错误

故事

Original link written in korean

建筑公司的建筑师乔迪（Jordi）收到客户的要求，要求对滚道的建设进行估算。根据提供的滚道设计图，滚道站点为N x N正方形网格的形式，每个网格为1 x 1。在设计图中，每个网格中的单元格都用0或1填充，其中0表示单元格是空的，而1表示单元格是用墙填充的。滚道的起点是（0，0）空间（左上），终点是（N-1，N-1）空间（右下）。

Jordi必须建造一条跑道，以使汽车从起点（0，0）可以安全地到达目的地（N-1，N-1）。可以通过上下左右两个相邻的空白空间来构造滚道，并且不能在带有墙的墙壁中建立滚道。此时，将上下两个相邻的空白区域或左右两个区域相连接的滚道称为直线路。

另外，两条直路以直角相交的点称为拐角。计算建筑成本，一条直线道路的成本为100美元，一个拐角角的成本为500美元。

Jordi需要计算建造跑道所需的最低成本，以便进行估算。

I / O示例

[[0,0]，[0,1,0]，[ 1,1]，[0,0]]

因为我是新人，所以无法发布图片。

answer = 3200

如果您建造一条像红色跑道一样的跑道，则需要花费3200韩元才能获得12条直线道路和4个弯道。如果您建造一条像蓝色小径的跑道，则10条直道和5个弯道的总费用为3500韩元，而且费用更高。

我的问题

我的代码占用大量运行时间，并且程序停止运行（运行时错误）... 我的新想法正在制作一个库。（x，y）的键值。如果BFS第一次到达（x，y），它将节省到达（x，y）的成本。如果BFS再次到达（x，y），并将其成本与现有价值进行比较。如果它大于价值，那么它没有添加到BFS中，这个想法怎么样？我没有在代码上使用这个想法，因为我担心这也会花费很长时间。

我想知道您的想法也有提示，但我听不懂

我的代码（原始代码，未使用新的想法）

from collections import deque
import copy
def check(a,b,board,n):
#checks if it can be added to queue#
    if b=='U':
        if a[0][0]>0 and board[a[0][0]-1][a[0][1]]!=1 and [a[0][0]-1,a[0][1]] not in a[3]:
            return True
    if b=='D':
        if a[0][0]<n-1 and board[a[0][0]+1][a[0][1]]!=1 and [a[0][0]+1,a[0][1]] not in a[3]:
            return True
    if b=='R':
        if a[0][1]<n-1 and board[a[0][0]][a[0][1]+1]!=1 and [a[0][0],a[0][1]+1] not in a[3]:
            return True
    if b=='L':
        if 0<a[0][1] and board[a[0][0]][a[0][1]-1]!=1 and [a[0][0],a[0][1]-1] not in a[3]:
            return True
    return False
def move(a,b):
# append next movement to queue,change direction and add Turn counts
    if b==a[1]:
        if b=='U':
            a[0][0]-=1
            return a
        if b=='D':
            a[0][0]+=1
            return a
        if b=='R':
            a[0][1]+=1
            return a
        if b=='L':
            a[0][1]-=1
            return a
    else:
        if b=='U':
            a[2]+=1
            a[0][0]-=1
            a[1]='U'
            return a
        if b=='D':
            a[2]+=1
            a[0][0]+=1
            a[1]='D'
            return a
        if b=='R':
            a[2]+=1
            a[0][1]+=1
            a[1]='R'
            return a
        if b=='L':
            a[2]+=1
            a[0][1]-=1
            a[1]='L'
            return a
def solution(board):
    value=[]
    n=len(board)
    d=0
    queue=deque()
    # In queue i added elements [current location,Direction,Turn Counts,visited dots in list]
    queue.append([[0,0],'R',[]])
    queue.append([[0,'D',[]])
    while len(queue)!=0:
        p=queue.popleft()

        #to use differnt lists in case of error in if loop

        Up=copy.deepcopy(p)
        Down=copy.deepcopy(p)
        Right=copy.deepcopy(p)
        Left=copy.deepcopy(p)
        past=p[0]
        Up[3].append(past)
        Down[3].append(past)
        Left[3].append(past)
        Right[3].append(past)
        p[3].append(past)
        #I thought the cheapest route can not be longer than shortest route+3
        if d!=0 and len(p[3])>d+3:
            answer = min(value)*100
            return answer
        if p[0]==[n-1,n-1]:
            value.append((len(p[3])-1)+5*p[2])
            d=len(p[3])-1
        if check(Up,'U',n)==True:
            queue.append(move(Up,'U'))
        if check(Down,n)==True:
            queue.append(move(Down,'D'))
        if check(Right,n)==True:
            queue.append(move(Right,'R'))
        if check(Left,'L',n)==True:
            queue.append(move(Left,'L'))
    answer = min(value)*100
    return answer

提示（仅供参考）

对于具有K拐角的最低成本，您可以尽可能减少直线道路的数量。这是通过制作K个拐角并找到从起点到目的地的最短路线来完成的。

现在，我们将状态空间S定义如下：

[垂直坐标R] [水平坐标C] [拐角数K] [看向D]→沿K拐角并看向D的方向到达（R，C）位置时的最短距离

这时，假设移动一个空间的成本为1，创建角的成本也为1。现在，它找到所有Ks到起点→目的地的最短路线。 BFS搜索代码编写如下：

根据上次查看的方向，它搜索三种情况：向左转，向右转和一直走。
在左右旋转的情况下，添加一个角并更改查看方向。
在笔直的情况下，朝您所看的方向前进一个空间。

按上述方式搜索BFS后，最终在（N – 1，N – 1）位置K = 1，2，3，…。找到案例的最短距离。此时，重要的是要注意，此处获得的最短距离是包括角数的值。因此，在具有K个拐角的最短距离内，施工成本可以计算如下：

（最短距离-K）x 100 + K * 500

那么这里的K值有多大？每个网格最多可以有1个角。如果是这样，则N x N网格中的角数应小于网格单元数。因此，拐角数K最多为N x N。

查找最便宜的路线转弯花费500，直走花费100-运行时错误