问题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次即可=-=