Python 更好的biggestPlus算法_Python_Algorithm

Python 更好的biggestPlus算法

python algorithm

Python 更好的biggestPlus算法,python,algorithm,Python,Algorithm,问题是在矩阵中找到最大的+（加号）：给定一个仅包含字符“0”和“1”的矩阵，找到由1组成的最大加号（+）并返回其秩。在这种情况下，秩表示加号边的长度。为了成为有效的加号，边的长度必须相等我目前的算法如下。基本上，它通过大小为n的矩阵，三次。首先，它通过它并确定其左/上1s的值。第二遍确定其右/下1的值。第三种方法比较生成的4个矩阵并找到最小值。这些值的最大值就是答案我想知道如何优化算法。矩阵的长度可以达到1000x1000。有没有一种方法可以通过检查一次矩阵来确定答案？如果是这样的话，那怎

问题是在矩阵中找到最大的+（加号）：

给定一个仅包含字符“0”和“1”的矩阵，找到由1组成的最大加号（+）并返回其秩。在这种情况下，秩表示加号边的长度。为了成为有效的加号，边的长度必须相等

我目前的算法如下。基本上，它通过大小为n的矩阵，三次。首先，它通过它并确定其左/上1s的值。第二遍确定其右/下1的值。第三种方法比较生成的4个矩阵并找到最小值。这些值的最大值就是答案

我想知道如何优化算法。矩阵的长度可以达到1000x1000。有没有一种方法可以通过检查一次矩阵来确定答案？如果是这样的话，那怎么办呢。还是有更好的方法来确定与此完全不同的答案

def biggestPlus(matrix):
    def get_left_up():
        dp_left = [[-1 for _ in row] for row in matrix]
        dp_up = [[ -1 for _ in row ] for row in matrix ]

        for y, row in enumerate(matrix):
            for x, val in enumerate(row):
                if val == '1':
                    #####FOR DP_LEFT
                    if x != 0:
                        dp_left[y][x] = dp_left[y][x-1] + 1
                    else:
                        dp_left[y][x] = 0

                    #####FOR DP_UP
                    if y != 0:
                        dp_up[y][x] = dp_up[y-1][x] + 1
                    else:
                        dp_up[y][x] = 0

        return dp_left, dp_up

    def get_right_down():
        dp_right = [[-1 for _ in row] for row in matrix]
        dp_down = [[-1 for _ in row] for row in matrix]

        for y in range(len(matrix)-1,-1,-1):
            row = matrix[y]
            for x in range(len(row) - 1, -1, -1):
                val = matrix[y][x]
                if val == '1':
                    #####FOR DP_RIGHT
                    if x < len(row)-1:
                        dp_right[y][x] = dp_right[y][x + 1] + 1
                    else:
                        dp_right[y][x] = 0

                    #####FOR DP_DOWN
                    if y < len(matrix)-1:
                        dp_down[y][x] = dp_down[y + 1][x] + 1
                    else:
                        dp_down[y][x] = 0

        return dp_right, dp_down

    def getBiggestPlus(dp_left,dp_up,dp_right,dp_down):
        #####GET MIN OF 4 MATRICES
        result = 0

        for y, row in enumerate(dp_left):
            for x, val in enumerate(row):
                minimum = min(dp_left[y][x],dp_down[y][x],dp_right[y][x],dp_up[y][x])
                result = max(result,minimum)         #####ANSWER IS THE MAX

        return result

    dp_left, dp_up = get_left_up()
    dp_right, dp_down = get_right_down()
    return getBiggestPlus(dp_left,dp_up,dp_right,dp_down)

在N行的正方形矩阵中，边长度为N的

必须具有长度为2n+1的水平部分，并且该部分不能从第N行上方或第N-N行下方开始，否则垂直边将不适合

这个最大可能的

只能位于矩阵的正中心

我将开始扫描矩阵中的水平线，并为它们寻找匹配的垂直线。给定剩余的垂直空间，我有一个变量k表示我仍然可以找到的最大正边。我从中间开始，k=N/2

在每一步中，我都会寻找长度不超过2k+1的水平延伸

s；一行中可以有几个。对于每一个，我会寻找一个匹配的垂直方向，扫描中心的柱

寻找最大值的通常想法适用；保留最广为人知的结果，如果发现更好的结果，请更换。在这里，如果k小于最为人所知的结果，停止是有意义的，并且忽略任何小于它的水平拉伸

获得最佳性能的诀窍是并行运行两次扫描，一次向上，一次向下，同步运行。它们也可以按顺序运行，但随后算法可能需要进行一次完全向上扫描，例如，查找不到任何内容，然后在底部靠近中间的位置找到一个较大的加号。使用lockstep执行时，最大的优点被发现得最快

编码由您决定，但我要编写的第一个函数是：

def find_horizontal_stretches(matrix, line, no_shorter_than=1):  
  """Returns a list of stretches as [(start, length),..],
     each no shorter than indicated.
  """

def has_vertical_stretch(matrix, line, column, size):
  """Returns True iff a column of 1s of given size is present
     at given column, and is centered at given line."""