广度优先搜索-鸣人和佐助

鸣人和佐助：佐助被大蛇丸诱骗走了，鸣人在多少时间内能追上他呢？
已知一张地图（以二维矩阵的形式表示）以及佐助和
鸣人的位置。地图上的每个位置都可以走到，只不过有些位置上有
大蛇丸的手下(#)，需要先打败大蛇丸的手下才能到这些位置。

鸣人有一定数量的查克拉，每一个单位的查克拉可以打败一
个大蛇丸的手下。假设鸣人可以往上下左右四个方向移动，
每移动一个距离需要花费1个单位时间，打败大蛇丸的手下
不需要时间。如果鸣人查克拉消耗完了，则只可以走到没有
大蛇丸手下的位置，不可以再移动到有大蛇丸手下的位置。
佐助在此期间不移动，大蛇丸的手下也不移动。请问，鸣人
要追上佐助最少需要花费多少时间？
输入：输入的第一行包含三个整数：M，N，T。代表M行N列的地图和
鸣人初始的查克拉数量T。0 < M,N < 200，0 ≤ T < 10
后面是M行N列的地图，其中@代表鸣人，+代表佐助。*代表通路，#代表大蛇丸的手下。
输出：输出包含一个整数R，代表鸣人追上佐助最少需要花费的时间。
如果鸣人无法追上佐助，则输出-1。
样例输入1
4 4 1
#@##
**##
###+
****
样例输出1
6

样例输入2
4 4 2
#@##
**##
###+
****
样例输出2
4

一个经典的错误样例；
3 6 1
@#**** 
*#*###
***##+
正确答案应该是11；
但是如果利用二维标记答案是-1；因为二维标记是bfs找最短路，
当（1，1）——>（2，1）——>（3，1）——>（3，2）——>（3，3）——>（2，3）——>（1，3），
当这样找到（1，3）时，（1，3）早已经被（1，1）——>（1，2）——>（1，3）
走过并标记了，所以这条不需要查克拉的路就走不下去了，输出-1；
用三维数组就可以避免这种情况；比如刚才走到（1，3）这个点，区分有0、1查克拉的情况
visited[1][3][0] = 1，走到该点(1,3)，用了1个，目前查克拉数量是0
visited[1][3][1] = 1，走到该点(1,3)，没有用过1查克拉，目前查克拉数量是1，
这样就可以描述通过不同路径走到该点，拥有查克拉的数量的三维数组来描述状态，
都是到达（1,3）这个点，但是查克拉的数量不一致，所以就是新的一种状态，这样就不与
之前的路产生冲突了。

思路：这道题的状态是什么？是又鸣人的所在位置以及鸣人所剩查克拉决定的，(i,j,n)，
初始状态是(i0,j0,N),终止状态是(i,i,n),达到佐助位置即可。
因为用广搜，所以到达即是最短。用广搜的话就要加入查克拉的消耗情况，
所以是三维的visit数组。
这题与以往不一样的地方在于该点走过后，还是可以再访问的，因为多了一个查克拉的值。

https://blog.csdn.net/WaveBridge/article/details/74993874

python代码：

import queue

# 地图
maps = []
# 分别代表鸣人和佐助的位置
r1, c1, r2, c2 = 0, 0, 0, 0
# 访问标记
visited = []
# 四个方向数组
direction = [[1, 0], [-1, 0], [0, 1], [0, -1]]


class Node:
    # 所在位置
    r = 0
    c = 0
    # 查克拉剩余
    t = 0
    # 所在层数，路径长度
    level = 0

    def __init__(self, rr, cc, tt, level1):
        self.r = rr
        self.c = cc
        self.t = tt
        self.level = level1


# 获取鸣人和佐助的r,c
def getTwoDimensionListIndex(list_map, value):
    r, c = 0, 0
    for i in range(len(list_map)):
        for j in range(len(list_map[i])):
            if list_map[i][j] == value:
                r = i
                c = j
                break
    return r, c


def bfs(r, c, k):
    global maps, r1, c1, r2, c2, visited
    new_node = Node(r1, c1, k, 0)
    q = queue.Queue()
    q.put(new_node)
    while not q.empty():
        temp = q.get()
        # 找到佐助
        if temp.r == r2 and temp.c == c2:
            cost_time = temp.level
            return cost_time
        # 把当前节点四个方向的节点入队
        for i in range(4):
            temp2 = Node(0, 0, 0, 0)
            temp2.r = temp.r + direction[i][0]
            temp2.c = temp.c + direction[i][1]
            # 保证访问的点不越界
            if 0 <= temp2.r < r and 0 <= temp2.c < c:
                # 若为"#"并且查克拉够 并且没访问过 可访问
                if maps[temp2.r][temp2.c] == "#" and temp.t >= 1 and visited[temp2.r][temp2.c][temp.t-1] == 0:
                    temp2.t = temp.t - 1
                    temp2.level = temp.level + 1
                    q.put(temp2)
                    visited[temp2.r][temp2.c][temp2.t] = 1
                # 不是# 并且未访问过
                elif maps[temp2.r][temp2.c] != "#" and visited[temp2.r][temp2.c][temp.t] == 0:
                    temp2.t = temp.t
                    temp2.level = temp.level + 1
                    q.put(temp2)
                    visited[temp2.r][temp2.c][temp2.t] = 1
    return 0


def main():
    global maps, r1, c1, r2, c2, visited
    # k-查克拉的数量
    r, c, k = map(int, input().split())

    for i in range(r):
        temp = list(input())
        maps.append(temp)
    # [['#', '@', '#', '#'],['*', '*', '#', '#'],
    #  ['#', '#', '#', '+'],['*', '*', '*', '*']]
    # 查找鸣人和佐助的位置
    r1, c1 = getTwoDimensionListIndex(maps, "@")
    r2, c2 = getTwoDimensionListIndex(maps, "+")
    visited = [[[0 for i in range(k+1)] for j in range(c)] for e in range(r)]
    """
    三维的visited列表
    [
        [[0, 0], [0, 0], [0, 0], [0, 0]], 
        [[0, 0], [0, 0], [0, 0], [0, 0]], 
        [[0, 0], [0, 0], [0, 0], [0, 0]], 
        [[0, 0], [0, 0], [0, 0], [0, 0]]
    ]
    """
    # 从这里出发，置状态为1，表示访问过
    visited[r1][c1][k] = 1
    rtn = bfs(r, c, k)
    if rtn == 0:
        print("-1")
    else:
        print("鸣人追上佐助最少需要花费的时间为:%d" % rtn)


if __name__ == '__main__':
    main()