Problem

Given a 2D array of integers, find the length of the longest path of consecutive integers starting from the top left corner of the array.
The path can move up, down, left, or right, but can only visit each cell once.
Example input:
[[1, 2, 3, 4],
 [2, 3, 4, 5],
 [3, 4, 5, 6],
 [4, 5, 6, 7]]
Example output:
7

Solution

# Solution:
# The optimal solution is to use a depth first search algorithm.
# The reason is that the depth first search algorithm will find the longest path first.
# The algorithm will start at the top left corner of the array and will search for the longest path.
# If the algorithm finds a path that is longer than the current longest path, it will update the longest path.
# The algorithm will continue to search for the longest path until it has visited every cell in the array.
# The algorithm will then return the longest path.

def longest_path(array):
    longest_path = 0
    visited = [[False for _ in range(len(array[0]))] for _ in range(len(array))]
    for i in range(len(array)):
        for j in range(len(array[0])):
            longest_path = max(longest_path, dfs(array, i, j, visited))
    return longest_path

def dfs(array, i, j, visited):
    if visited[i][j]:
        return 0
    visited[i][j] = True longest_path = 1
    for x, y in [(i-1, j), (i+1, j), (i, j-1), (i, j+1)]:
        if 0 <= x < len(array) and 0 <= y < len(array[0]) and array[x][y] == array[i][j] + 1:
            longest_path = max(longest_path, 1 + dfs(array, x, y, visited))
    visited[i][j] = False
    return longest_path

print(longest_path([[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7]]))