Arrays 字母矩阵中最长的连续路径

我试图解决这个问题：

给定一个n*m的矩阵，用字母（字符）查找矩阵中字母的最长连续路径并输出字符串。例如：

m = [[a,c,d],[i,b,e],[h,g,f]]

result = e,f,g,h

您只能在矩阵中上下左右移动。这是我到目前为止在网上获得的一些信息，但我还没有完全做到这一点。 我还希望使解决方案更高效，因为我当前的代码可能有太多的循环，对于大型矩阵来说可能速度较慢。任何帮助都将不胜感激

R = len(matrix)
C = len(matrix[0])

x = [0, 1, 0, -1]
y = [1, 0, -1, 0]

dp=[[0 for i in range(C)]for i in range(R)]

def isvalid( i, j):
    if (i < 0 or j < 0 or i >= R or j >= C):
        return False
    return True

def getLenUtil(matrix, i, j, prev):
    if (isvalid(i, j)==False or isadjacent(prev, mat[i][j])==False):
        return 0
    if (dp[i][j] != -1):
        return dp[i][j]

    ans = 0

    for k in range(4):
        ans = max(ans, 1 + getLenUtil(mat, i + x[k],j + y[k], mat[i][j]))

    dp[i][j] = ans
    return dp[i][j]

def isadjacent(prev, curr):
    if (ord(curr) -ord(prev)) == 1:
        return True
    return False

def findLongestSequence(matrix):
    for i in range(R):
        for j in range(C):
            dp[i][j]=-1
    ans = 0
    for i in range(R):
        for j in range(C):
            if (mat[i][j] == s):
                for k in range(4):
                    ans = max(ans, 1 + getLenUtil(matrix, i + x[k], j + y[k], s));
     return ans

R=len（矩阵）
C=len（矩阵[0]）
x=[0,1,0，-1]
y=[1,0，-1,0]
dp=[[0代表范围（C）中的i]代表范围（R）中的i]
def有效（i，j）：
如果（i<0或j<0或i>=R或j>=C）：
返回错误
返回真值
def getLenUtil（矩阵，i，j，prev）：
如果（isvalid（i，j）=False或isadjacent（prev，mat[i][j]）==False）：
返回0
如果（dp[i][j]！=-1）：
返回dp[i][j]
ans=0
对于范围（4）中的k：
ans=max（ans，1+getLenUtil（mat，i+x[k]，j+y[k]，mat[i][j]））
dp[i][j]=ans
返回dp[i][j]
def不相邻（上、当前）：
如果（订单（当前）-订单（上一次））==1：
返回真值
返回错误
def findLongestSequence（矩阵）：
对于范围（R）内的i：
对于范围（C）内的j：
dp[i][j]=-1
ans=0
对于范围（R）内的i：
对于范围（C）内的j：
如果（mat[i][j]==s）：
对于范围（4）中的k：
ans=max（ans，1+getLenUtil（矩阵，i+x[k]，j+y[k]，s））；
返回ans

代码中的几个问题：

• mat

  和

  matrix

  拼写应该统一

• s

  从未初始化
• 在

  R=len（矩阵）

  和对

  mat

  或

  matrix

  的几个其他引用中，未定义该变量

  findLongestSequence

  是用

  matrix

  的实际值调用的，因此应该定义

  R

  ，等等

而且

• 如果不传递

  prev

  ，而是传递实际期望的字符（已“递增”），则更容易
• 为什么先用零初始化

  dp

  ，然后用-1重新初始化？立即使用-1即可

以下是它的工作原理：

def findLongestSequence(mat):
    R = len(mat)
    C = len(mat[0])

    x = [0, 1, 0, -1]
    y = [1, 0, -1, 0]

    dp = [[-1 for i in range(C)] for i in range(R)]

    def isvalid( i, j):
        return (0 <= i < R) and (0 <= j < C)

    def getLenUtil(mat, i, j, expected):
        if not isvalid(i, j) or mat[i][j] != expected:
            return 0

        if dp[i][j] == -1:
            ans = 0
            expected = chr(ord(mat[i][j])+1)
            for k in range(4):
                ans = max(ans, 1 + getLenUtil(mat, i + x[k], j + y[k], expected))

            dp[i][j] = ans
        return dp[i][j]

    ans = 0
    for i in range(R):
        for j in range(C):
            getLenUtil(mat, i, j, mat[i][j])
        ans = max(ans, max(dp[i]))
    print(dp)
    return ans

res = findLongestSequence([["a","c","d"],["i","b","e"],["h","g","f"]])
print(res)

def findlongest序列（mat）：
R=透镜（mat）
C=len（mat[0]）
x=[0,1,0，-1]
y=[1,0，-1,0]
dp=[-1代表范围（C）内的i]代表范围（R）内的i]
def有效（i，j）：
return（0）您在哪里定义了
s
？mat

和

matrix

之间似乎也不匹配。您调试了此代码吗？为什么示例4的答案是从“b”到“i”的路径？为什么不是8？非常感谢，是的，我在语法上犯了一些错误，而且不一致。这是一种更简单的方法。如果我不显示连续字符的长度，而是想输出字符本身，你会建议我怎么做？你会返回一个列表。因此

return 0

变成

return[]

，

ans=0

变成

ans=[]

ans=max（…）

变成更复杂的东西，你可以在那里比较

len（ans）

递归返回的长度。如果后者等于或更长，则让

ans

成为返回列表加上当前字母，否则不要碰它。尝试一下。如果遇到问题，请提出新问题。