Question

问题是找到给定网格的0值点的所有建筑物的最短距离。您只能向上，向下，向左和向右移动。您可能会遇到以下值：

0 - 空的空间 1 - 建筑 2 - 障碍

我用Python编写的解决方案如下：

import sys

class Solution(object):
    def shortestDistance(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        if grid is None:
            return -1

        tup = self.findPoints(grid)
        buildings = tup[0]
        zeroPoints = tup[1]
        distances = []
        for points in zeroPoints:
            dist = self.bfs(grid, points, buildings)
            distances += [dist]

        return self.select(distances)

    def findPoints(self, grid):
        buildings = 0
        zeroPoints = []
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if grid[i][j] == 0:
                    zeroPoints += [[i,j]]
                elif grid[i][j] == 1:
                    buildings += 1
        return (buildings, zeroPoints)

    def bfs(self, grid, root, targets):
        hits, sumDist = 0, 0
        targetsFound = []

        while hits < targets:
            q = []
            q.append((root, 0))
            found = False
            visited = []
            while(len(q) > 0):
                tup = q.pop(0)
                curr = tup[0]
                dist = tup[1]

                if grid[curr[0]][curr[1]] == 1 and curr not in targetsFound:
                    found = True
                    sumDist += dist
                    targetsFound += [curr]
                    break

                if grid[curr[0]][curr[1]] == 0:
                    if (curr[0] - 1) >= 0 and grid[curr[0] -1][curr[1]] != 2 and [curr[0] - 1, curr[1]] not in visited:
                        q.append(([curr[0] - 1, curr[1]], dist + 1))
                        visited += [[curr[0] - 1, curr[1]]]
                    if (curr[0] + 1) < len(grid) and grid[curr[0] + 1][curr[1]] != 2 and [curr[0] + 1, curr[1]] not in visited:
                        q.append(([curr[0] + 1, curr[1]], dist + 1))
                        visited += [[curr[0] + 1, curr[1]]]
                    if (curr[1] - 1) >= 0 and grid[curr[0]][curr[1] - 1] != 2 and [curr[0], curr[1] - 1] not in visited:
                        q.append(([curr[0], curr[1] - 1], dist + 1))
                        visited += [[curr[0], curr[1] - 1]]
                    if (curr[1] + 1) < len(grid[0]) and grid[curr[0]][curr[1] + 1] != 2 and [curr[0], curr[1] + 1] not in visited:
                        q.append(([curr[0], curr[1] + 1], dist +1))
                        visited += [[curr[0], curr[1] + 1]]

            if found:
                hits += 1
            else:
                return - 1

        return sumDist

    def select(self, distances):
        min = sys.maxsize
        for dist in distances:
            if dist < min and dist != -1:
                min = dist

        if min == sys.maxsize:
            return -1
        else:
            return min

我的问题是：

如何提高解决方案的效率？现在我在以下输入上超过了Leetcode的时间限制，但它对所有其他测试输入都是正确的：

[[2,0,0,2,0,0,0,0,0,2,2,0,0,0,0,0,0,0,0,0,1,2,0,2,0,1,1,0],[0,1,0,1,1,2,0,0,2,0,0,2,0,2,2,0,2,0,2,0,0,0,0,0,0,0,0,0],[1,0,0,1,2,0,0,2,0,2,0,0,0,0,0,0,0,0,0,2,0,2,0,0,0,0,0,2],[0,0,2,2,2,1,0,0,2,0,0,0,0,0,0,0,0,0,2,2,2,2,1,0,0,0,0,0],[0,2,0,2,2,2,2,1,0,0,0,0,1,0,2,0,0,0,0,2,2,0,0,0,0,2,2,1],[0,0,2,1,2,0,2,0,0,0,2,2,0,2,0,2,2,2,2,2,0,0,0,0,2,0,2,0],[0,0,0,2,1,2,0,0,2,2,2,1,0,0,0,2,0,2,0,0,0,0,2,2,0,0,1,1],[0,0,0,2,2,0,0,2,2,0,0,0,2,0,2,2,0,0,0,2,2,0,0,0,0,2,0,0],[2,0,2,0,0,0,2,0,2,2,0,2,0,0,2,0,0,2,1,0,0,0,2,2,0,0,0,0],[0,0,0,0,0,2,0,2,2,2,0,0,0,0,0,0,2,1,0,2,0,0,2,2,0,0,2,2]]

注意：更改visited和targetsFound可以提高效率，但不足以通过所有测试用例。

更新

通过将算法更改为从每个建筑物而不是每个零点进行搜索，我能够在某些大型输入上将算法提高96％并通过所有测试用例。更新的算法如下。感谢Nether的建议。

def shortestDistanceWalk(grid):

    onePoints = findPointsWalk(grid)

    for point in onePoints:
        bfsWalk(grid, point)

    shortestDistance = sys.maxsize
    for i in range(len(grid)):
        for j in range(len(grid[0])):
            if grid[i][j] < 0 and shortestDistance > (grid[i][j] * -1):
                shortestDistance = (grid[i][j] * -1)

    if shortestDistance == sys.maxsize:
        return -1
    else:
        return shortestDistance

def findPointsWalk(grid):
    onePoints = []
    for i in range(len(grid)):
        for j in range(len(grid[0])):
            if grid[i][j] == 1:
                onePoints += [[i,j]]
    return onePoints

def bfsWalk(grid, root):
    q = []
    q.append((root, 0))
    found = False
    visited = set()
    while(len(q) > 0):
        tup = q.pop(0)
        curr = tup[0]
        dist = tup[1]

        if grid[curr[0]][curr[1]] <= 0:
            grid[curr[0]][curr[1]] += dist

        if (curr[0] - 1) >= 0 and grid[curr[0] -1][curr[1]] <= 0  and (curr[0] - 1, curr[1]) not in visited:
            q.append(([curr[0] - 1, curr[1]], dist - 1))
            visited.add((curr[0] - 1, curr[1]))
        if (curr[0] + 1) < len(grid) and grid[curr[0] + 1][curr[1]] <= 0 and (curr[0] + 1, curr[1]) not in visited:
            q.append(([curr[0] + 1, curr[1]], dist - 1))
            visited.add((curr[0] + 1, curr[1]))
        if (curr[1] - 1) >= 0 and grid[curr[0]][curr[1] - 1] <= 0 and (curr[0], curr[1] - 1) not in visited:
            q.append(([curr[0], curr[1] - 1], dist - 1))
            visited.add((curr[0], curr[1] - 1))
        if (curr[1] + 1) < len(grid[0]) and grid[curr[0]][curr[1] + 1] <= 0 and (curr[0], curr[1] + 1) not in visited:
            q.append(([curr[0], curr[1] + 1], dist - 1))
            visited.add((curr[0], curr[1] + 1))

    for i in range(len(grid)):
        for j in range(len(grid[0])):
            if (i, j) not in visited:
                grid[i][j] = 3

    return

Answer 1

将targetsFound变量更改为set。您使用该变量的原因是查找是否已访问过某个单元格，并且列表中的查找是否为 O（N）时间较慢。设置支持快速查找 O（1），因此应该大大提高算法的性能。

有关O（N）和O（1）含义的更多信息：https://www.youtube.com/watch?v=v4cd1O4zkGw&t=1s

优化算法，找到所有建筑物的最短距离

1 个答案: