Maximum number of elements in the path of a matrix

Question

I tried to solve a problem of map (matrix 4x4) using python.

I want to find Maximum number of elements in the path of a map provided the next node must be lesser than the previous node with all possible combinations of elements in the matrix.

The movement is like from an element can move to east-west-north-south

For example from m[0][1] can move to m[0][2] and m[1][1] 4-> 8 or 2

Here is the sample code but i have no idea to how to recursively check every element.

#import itertools
n = 4 
matrix = [[4, 8, 7, 3 ], [2, 5, 9, 3 ], [6, 3, 2, 5 ], [4, 4, 1, 6]]
for index,ele in enumerate(matrix):
    vals=[]
    for i2,e2 in enumerate(ele):
        for index2,ele2 in enumerate(ele):
            if index < (n-1):
                if ele2 > matrix[index+1] [index2]:
                    vals.append(matrix[index+1] [index2])
            if index > 0:
                if ele2 > matrix[index-1] [index2]:
                    vals.append(matrix[index-1] [index2])
            if index2 < n-1:
                if ele2 > matrix[index] [index2+1]:
                    vals.append(matrix[index] [index2+1])
            if index2 >0:
                if ele2 > matrix[index] [index2-1]:
                    vals.append(matrix[index] [index2-1])

how to recurse this function to loop till the end

For Example the answer will be like 8-5-3-2-1 (Longest Path with decreasing factor)

What do you mean by Maximum Depth? Please clarify your desired output. — Rohcana, Aug 03 '15 at 08:50
@Anachor I suppose it's about seeking the longest path on the square (or rectangular) board which results in a (strictly) decreasing sequence of numbers. But that's just a guess... — CiaPan, Aug 03 '15 at 08:54
So state it in the question. Try also to indicate the problem nature in the title, as 'a depth of a matrix' tells nothing about the specific problem you're solving. — CiaPan, Aug 03 '15 at 08:57

tobias_k · Accepted Answer · 2015-08-03T09:28:09.933

Try this recursion: The longest path starting at element (x, y) is the longest longest path starting at any of its strictly smaller neighbors, plus 1.

def longest_path(matrix):
    def inner_longest_path(x, y):
        best, best_path = 0, []
        # for all possible neighbor cells...
        for dx, dy in ((+1, 0), (-1, 0), (0, +1), (0, -1)):
            # if cell is valid and strictly smaller...
            if (0 <= x + dx < len(matrix) and 0 <= y + dy < len(matrix[x]) 
                    and matrix[x+dx][y+dy] < matrix[x][y]):
                n, path = inner_longest_path(x+dx, y+dy)
                # check if the path starting at that cell is better
                if n > best:
                    best, best_path = n, path
        return best + 1, [matrix[x][y]] + best_path

    return max(inner_longest_path(x, y) for x, row in enumerate(matrix) 
                                        for y, _ in enumerate(row))

Note that this will do a lot of duplicate calculations. Adding memoization is left as an excercise to the reader.

Example:

>>> longest_path(matrix)
(5, [9, 5, 3, 2, 1])

Maximum number of elements in the path of a matrix

1 Answers1

Linked