問題1：在一個m*n的網格里，從左上到右下一共有多少種路徑，要求，只能向右或向下走？（m,n>0）

程式碼及註釋如下：

#!/usr/bin/python
def get_case(m,n):
	#m,n分別為網格的行列數
	#建立一個列表
	#f[i][j]表示從左上開始到第i行第j列的點的路徑數
	f = [[0]*n]*m
	#f[0][0]表示初始情況
	f[0][0] = 1
	for i in range(m):
		#先行
		for j in range(n):
			#後列
			#邊界條件，在最上面行或者在最左邊的列
			if i == 0 or j == 0:
				f[i][j] = 1
			else:
				#          上面走下來+左邊走過來
				f[i][j] = f[i-1][j]+f[i][j-1]
	return f[m-1][n-1]

m = 3
n=4
print(get_case(m,n))
 

若網格有障礙，且1表示不能通過，0表示可以通過，如何解？

程式碼及註釋如下：

def get_case(A):
    m,n = len(A),len(A[0])
    if m == 0 or n == 0:
        return 0
    f = [[0 for x in range(n)] for y in range(m)]
    for i in range(m):
        for j in range(n):
            #若有障礙，則路徑數位0
            if A[i][j] == 1:
                f[i][j] == 0
            else:
                #無障礙
                if i == 0 and j == 0:
                    #初始條件，f[0][0]=1
                    f[i][j] = 1
                else:
                    if i-1 >= 0:
                        # 從上邊走下來
                        f[i][j] += f[i-1][j]
                    if j-1 >= 0:
                        # 從左邊走過來
                        f[i][j] += f[i][j-1]
    return f[m-1][n-1]
a = [[0,0,0],[0,1,0],[0,0,0]]
print(get_case(a))
輸出為2
 

問題2：在一個m*n的網格里，每個網格里都有一個非負的數A[i][j],求從A[0][0]左上到右下的使得路徑上數字之和最小的路徑是多少，要求，只能向右或向下走？

註釋及程式碼如下：

import sys
def shortest_path(A):
    #f[i][j]表示從[0][0]到[i][j]最小數字和
    m,n = len(A),len(A[0])
    if m == 0 or n==0:
        return 0
    f = [[0 for x in range(n)] for y in range(2)]
    #空間優化old表示i-1行，now是i行
    old ,now  = 1,0
    for i in range(m):
        old ,now = now ,old          #old是i-1行,now是i行
        for j in range(n):
            #初始條件f[0][0]=A[0][0]
            if  i==0 and j==0:
                f[now][j] == A[i][j]
                continue
                
            f[now][j] = A[i][j]
            #如果上面有一行，即不是第0行
            if i > 0:
                temp1 = f[old][j]
            else:
                temp1 = sys.maxsize
            #如果有左邊一列,即不是第1列
            if j > 0:
                temp2 = f[now][j-1]
            else:
                temp2 = sys.maxsize
            
            f[now][j] += min(temp1,temp2)
            
#             if temp1 < temp2:
#                 f[now][j] += temp1
#             else:
#                 f[now][j] += temp2

    return f[now][n-1]
a = [[1,2,2],[1,2,3],[1,1,1]]
print(shortest_path(a))

結果：4
 

注：時間複雜度為O(mn)，空間複雜度是O(2n),其實，空間還可以優化到O(n)

問題3：在一個M*N的網格里，‘0’表示空地，‘W’表示牆,，‘E’表示敵人
現可以在空地放置炸彈，能炸死炸彈位置同行同列的所有敵人，但不能穿透牆。
問：最多能炸死多少個敵人？

程式碼及註釋如下：

#我們考慮每個格子不同方向上能炸死的敵人數，返回能炸死最多的那個敵人數
def bomb_enemies(A):
    m,n = len(A),len(A[0])
    #先初始化最後結果是0
    result = 0
    if m == 0 and n == 0:
        return 0
    f = [[0 for x in range(n)] for y in range(m)]
    
    #res[i][j]表示在格子[i][j]可以炸死四個方向的敵人數，初始化為0
    res = [[0 for x in range(n)] for y in range(m)]
    
    #f[i][j]表示格子[i][j]向上能炸死的人數
    for i in range(m):
        for j in range(n):
            #如果是牆，我們假設沒有敵人
            if A[i][j] == 'W':
                f[i][j] = 0
            else:
                #有敵人的情況
                #先初始化為0
                f[i][j] = 0
                #若格子[i][j]是敵人，先置為1，因為是從上到下累加
                if A[i][j] == 'E':
                    f[i][j] = 1
                if i-1 >= 0:#格子[i][j]上面有格子
                    #累加
                    f[i][j] += f[i-1][j]
            #將向上能炸死的敵人數累加到res裡
            res[i][j] += f[i][j]
            
    #f[i][j]表示格子[i][j]向下能炸死的人數
    #這裡應該從下向上計算f[i][j],即先從最後一行開始計算
    for i in range(m-1,-1,-1):
        for j in range(n):
            #如果是牆，我們假設沒有敵人
            if A[i][j] == 'W':
                f[i][j] = 0
            else:
                #有敵人的情況
                #先初始化為0
                f[i][j] = 0
                #若格子[i][j]是敵人，先置為1，因為是從下到上累加
                if A[i][j] == 'E':
                    f[i][j] = 1
                if i+1 < m:#格子[i][j]下面有格子
                    #累加
                    f[i][j] += f[i+1][j]
            #將向下能炸死的敵人數累加到res裡
            res[i][j] += f[i][j]
    
    #同理求向左和向右的情況
    #f[i][j]表示格子[i][j]向左能炸死的人數
    for i in range(m):
        for j in range(n):
            #如果是牆，我們假設沒有敵人
            if A[i][j] == 'W':
                f[i][j] = 0
            else:
                #有敵人的情況
                #先初始化為0
                f[i][j] = 0
                #若格子[i][j]是敵人，先置為1，因為是從上到下累加
                if A[i][j] == 'E':
                    f[i][j] = 1
                if j-1 >= 0:#格子[i][j]左邊有格子
                    #累加
                    f[i][j] += f[i][j-1]
            #將向左能炸死的敵人數累加到res裡
            res[i][j] += f[i][j]


    #f[i][j]表示格子[i][j]向右能炸死的人數
    #先從最後一列開始計算
    for i in range(m):
        for j in range(n-1,-1,-1):
            #如果是牆，我們假設沒有敵人
            if A[i][j] == 'W':
                f[i][j] = 0
            else:
                #有敵人的情況
                #先初始化為0
                f[i][j] = 0
                #若格子[i][j]是敵人，先置為1
                if A[i][j] == 'E':
                    f[i][j] = 1
                if j+1 < n:#格子[i][j]右邊有格子
                    #累加
                    f[i][j] += f[i][j+1]
            #將向右能炸死的敵人數累加到res裡
            res[i][j] += f[i][j]
    #此時res[i][j]表示的是格子[i][j]向四個方向能炸死的敵人數
    for i in range(m):
        for j in range(n):
            #如果是空地
            if A[i][j] == '0' :
                #如果空地能炸死的敵人有更大的數量，則更新最終結果result
                if res[i][j] > result:
                    result = res[i][j]
    return result

            
A = [['0','E','0','0'],['E','0','W','E'],['0','E','0','0']]
print(bomb_enemies(A))

結果是3

注：如果給出的矩陣是方陣，不用四個迴圈來計算四個方向的敵人數，讓方陣轉向3次即可=-=