算法之--回溯法-迷宮問題【python實現】

題目描述

定義一個二維數組N*M（其中2<=N<=10;2<=M<=10），如5 × 5數組下所示： 

int maze[5][5] = {

        0, 1, 0, 0, 0,

        0, 1, 0, 1, 0,

        0, 0, 0, 0, 0,

        0, 1, 1, 1, 0,

        0, 0, 0, 1, 0,

};

表示一個迷宮，其中的1表示牆壁，0表示可以走的路，只能橫着走或豎着走，不能斜着走，要求編程序找出從左上角到右下角的最短路線。入口點為[0,0]，即第一空格是可以走的路。

Input

一個N × M的二維數組，表示一個迷宮。數據保證有唯一解,不考慮有多解的情況，即迷宮只有一條通道。

Output

左上角到右下角的最短路徑，格式如樣例所示。

Sample Input

0 1 0 0 0

0 1 0 1 0

0 0 0 0 0

0 1 1 1 0

0 0 0 1 0

Sample Output

(0, 0)

(1, 0)

(2, 0)

(2, 1)

(2, 2)

(2, 3)

(2, 4)

(3, 4)

(4, 4)

分析

元素--狀態空間分析：每個坐標是是一個元素，每次可以在上一個坐標基礎上向右[0,1]或者向下[1,0]移動一步。所以這里可以看出，元素是不固定的，狀態空間固定。

代碼

while True:
    try:
        n = list(map(int,input().split()))   # 輸入一個N*M的數組
        N = n[0]
        M = n[1]
        m = []
        x,y = 0,0
        result = [[x,y]]   # 定義其實位置0，0
        for i in range(N):  # 依次輸入二維數組，組成一個N*m的數組
            m.append(list(map(int,input().split())))

        # 沖突檢測，如果下一步是1 ，表示為牆，沖突了
        def conflict(i):
            if m[i[0]][i[1]] == 1:
                return True
            return False  # 無沖突

        # 回溯法（遞歸版）
        def foo():
            global x, y, result

            if x == N-1 and y == M-1:  # 判斷是否到終點
                for i in result:
                    print('({},{})'.format(i[0],i[1]))

            else:
                for j in [[0,1],[1,0]]:  # 元素空間為[0,1],[1,0]
                    # 向對應方向挪動一步
                    x += j[0]
                    y += j[1]
                    if x > N-1 or y > M-1:  # 如果超出邊界，回退
                        x -= j[0]
                        y -= j[1]
                        continue
                    s = [x,y]
                    result.append(s)   # 加入這個坐標
                    if not conflict(s):
                        foo()   # 如果不沖突，繼續下一步
                    result.pop()   #如果沖突，刪除剛才加入的這個坐標點，並執行下面兩步回退
                    x -= j[0]
                    y -= j[1]
        foo()
    except:
        break