Question

我有一个二维网格的整数尺寸（n1xn2）：

1 4 3
3 5 7
2 6 4

目标是找到具有最高总和的从左到右的路径。例如，在这种情况下，总和将是3 + 6 + 7 = 16。该路径只能向东移动，只能移动到自己的邻居（即你不能从2跳到4，因为4超过一个单位）。

我的问题是我可以找到哪些方法并在知道其尺寸的网格上存储每个可能的路径？是否有助于将整个网格存储在int[rows][cols]或int[cols][rows]的2D数组中？我认为这将以递归的方式完成。

我知道有类似的问题，但我无法从他们那里制定出有效的解决方案。任何帮助将不胜感激。

Answer 1

我可以在给定网格上找到并存储每个可能路径的方法

对于每个可能的起点（每行的第一个条目），使所有可能的移动向右，向上/向下/向下移动到板上。这可能有很好的递归解决方案。

int[rows][cols]或int[cols][rows]

我通常使用int[rows][cols]，因为我可以清楚地想到它 - 请记住，这意味着您必须以grid[y][x]的形式访问它，这可能会让您感到奇怪。

Answer 2

这是我做过的一次尝试，它可以运行但是它在python中。矩阵按列存储，基本思路是从左到右创建矩阵中所有可能路径的列表，然后在最后找到具有最大值的路径。

对于每个项目，获取可能的子路径列表并附加当前项目。子路径是递归生成的。

我知道它不是Java，但逻辑是一样的，希望这会有所帮助。

matrix = [[1,3,2],[4,5,6],[3,7,4]]


def findMax(pathList): 
    maxPath = []
    maxVal = 0
    for path in pathList:
        add =  sum(path)
        if add > maxVal:
            maxVal = add
            maxPath = path
    print "Path: " + str(maxPath) + " val: "+str(maxVal)     

def iterateMatrix(args): #initial method
    firstcol = args[0] #pop off first column
    allpaths = []
    for i in range(0,len(firstcol)): 
        childPaths = iterateChildren(args,1) #grab all possible subpaths
        for x in range(0,len(childPaths)):
            allpaths.append([firstcol[i]]+childPaths[x])
    print allpaths
    #built a list of all possible paths from left to right
    #now iterate and calculate the sum
    findMax(allpaths)

def iterateChildren(args,index):#build up a list of possible combinations of columns in the matrix
    paths = []
    if index == (len(args)-1): #if there are no more possible sub-paths to compute
        for i in range(0,len(args[index])):
            paths.append(args[index][i])
        return paths
    else:
        childPaths = iterateChildren(args, index+1)
        for x in range(0,len(args[index])):
            for y in range(0,len(childPaths)):
                paths.append([args[index][x],childPaths[y]])
    return paths

iterateMatrix(matrix)

使用特定规则在2d区域找到最佳路径

2 个答案: