Longest Increasing Path In A 2D Matrix
You have been given a MATRIX of non-negative integers of size N x M where 'N' and 'M' denote the number of rows and columns, respectively.

Your task is to find the length of the longest increasing path when you can move to either four directions: left, right, up or down from each cell. Moving diagonally or outside the boundary is not allowed.

Note: A sequence of integers is said to form an increasing path in the matrix if the integers when traversed along the allowed directions can be arranged in strictly increasing order. The length of an increasing path is the number of integers in that path.

For example :

3 2 2 5 6 6 9 5 11 In the given matrix, 3 → 5 → 6 and 3 → 5 → 9 form increasing paths of length 3 each.

Input Format :

The first line of input contains an integer 'T' representing the number of test cases or queries to be processed. Then the test case follows. The first line of each test case contains two space-separated integers 'N', 'M' where 'N' and 'M' denote the number of rows and columns of the matrix, respectively. From the second line of each test case, the next 'N' lines represent the rows of the MATRIX. Every row contains 'M' single space-separated integers.

Output Format :

For each test case, print the length of the longest increasing path. Print the output of each test case in a separate line. Note : You do not need to print anything; it has already been taken care of. Just implement the function.

Constraints :

1

Question

Longest Increasing Path In A 2D Matrix

You have been given a MATRIX of non-negative integers of size N x M where 'N' and 'M' denote the number of rows and columns, respectively.

Your task is to find the length of the longest increasing path when you can move to either four directions: left, right, up or down from each cell. Moving diagonally or outside the boundary is not allowed.

Note: A sequence of integers is said to form an increasing path in the matrix if the integers when traversed along the allowed directions can be arranged in strictly increasing order. The length of an increasing path is the number of integers in that path.

For example :

3 2 2
5 6 6
9 5 11 

In the given matrix, 3 →  5 →  6 and 3 →  5 →  9 form increasing paths of length 3 each.

Input Format :

The first line of input contains an integer 'T' representing the number of test cases or queries to be processed. Then the test case follows.

The first line of each test case contains two space-separated integers 'N', 'M' where 'N' and 'M' denote the number of rows and columns of the matrix, respectively.

From the second line of each test case, the next 'N' lines represent the rows of the MATRIX. Every row contains 'M' single space-separated integers.

Output Format :

For each test case, print the length of the longest increasing path.

Print the output of each test case in a separate line.

Note :
You do not need to print anything; it has already been taken care of. Just implement the function.

Constraints :

1 <= T <= 100
1 <= N <= 50
1 <= M <= 50
0 <= MATRIX[i] <= 10^5

Time Limit: 1sec

Accepted Answer

The task is to find the length of the longest increasing path in a 2D matrix, where you can move in four directions: left, right, up, or down from each cell.

Traverse the matrix and for each cell, find the longest increasing path starting from that cell
Use dynamic programming to store the length of the longest increasing path for each cell
Recursively explore all four directions from each cell, checking if the next cell is greater than the current cell
Keep track of the maximum length of increasing path encountered

Accepted Answer

This was one of the most interesting questions I faced in all my campus interviews . I was initially thinking of using recursion and then optimising it through memoisation but there was a risk of getting TLE . I then observed that this question can be transformed into a Topological Sort+DP question where I was required to find the length of the longest chain ending at a particular index .

Steps :
1) Construct a graph (adjacency list) from the given matrix .
2) For every (i,j) check its 4 directions up,down,left,right .
3) If arr[i+1][j] > arr[i][j] , add a directed graph from (i,j) to (i+1,j).
4) Similarly, perform these steps for the other 3 directions.
5) Also , increment the indegree of the node to which we direct the edge
6) Now, initialise a queue of pair of int . Add all those nodes whose indegree was 0
7) Perform a standard BFS Topo Sort i.e., run a loop till my queue becomes empty and update the dp[node] (which stores the max length of a increasing chain ending at node) .
8) Finally, return the max value of dp[node] for all nodes.

Accepted Answer

DFS

The idea is to use DFS to find the length of the increasing path for every element.

We traverse the matrix and find the length of the longest increasing path starting from each cell.

For each element, check if it is valid to move in the four directions one by one and skip cells that are out of boundary or for which mat[x][y] > mat[dx][dy].
1. If valid, we perform DFS for the new cell. The longest length of the path is updated during search and the final answer is found when the search is finished.
2. Else, we return 1 as answer.
We do this for all cells and keep track of maximum length found so far. Finally, we return it as our answer.

Space Complexity: O(m*n) - For 2d arraysExplanation:

O(N*M), where N and M denote the number of rows and columns, respectively.

O(H) stack space is used in each depth first search where H is the maximum depth of the recursion. In the worst case, H = N*M.

Time Complexity: OtherExplanation:

O(4^(N*M)) where N and M denote the number of rows and columns, respectively.

We perform a DFS for every element. In the worst case, when elements in rows and columns are sorted in ascending order, we move from each cell in the matrix to all 4 neighbouring larger elements, and then from each of those elements to all of their neighbouring larger elements.

Therefore, the overall time complexity is O(4^(N*M)).

Accepted Answer

DFS with memoization

In the previous approach, the longest path starting from each cell is calculated again every time that cell is revisited. So, the idea is to use DFS with memoization to improve time complexity.

We maintain a 2D array dp of size N*M. Since the increasing path can start from any point in the matrix, we use dp[i][j] to store the length of the longest increasing path starting from location (i, j). This ensures that we do not recalculate a visited location.

Now, we perform a DFS from each cell with the current cell as (x, y). We compare the cells in the four directions (dx, dy) and skip cells that are out of boundary or for which mat[x][y] > mat[dx][dy].
1. If the cell (dx, dy) satisfies the conditions, we perform dfs from that cell and update maxLen as max of maxLen and 1 + (dfs from dx, dy).
We then update dp[x][y] with maxLen.
Finally, we return the maximum length of the increasing path as result.

Space Complexity: O(m*n) - For 2d arraysExplanation:

O(N*M), where N and M denote the number of rows and columns, respectively.

O(H) stack space is used in each depth first search where H is the maximum depth of the recursion. In the worst case, H = N*M. Also, we are maintaining a dp array of size N*M to store the length of the longest increasing path starting from each cell.

Time Complexity: O(m*n) - For 2d arraysExplanation:

O(N*M) where N and M denote the number of rows and columns, respectively.

We perform a DFS for each cell where every cell that has been computed once is not computed again, only a look-up is performed. This takes O(N*M) time. Traversing dp to find the max length also takes O(N*M) time.

Therefore, the overall time complexity is O(N*M).

Java (SE 1.8)

/*
    Time Complexity: O(N*M)
    Space Complexity: O(N*M)

    where 'N' and 'M' denote the number of rows and columns.
*/

import java.util.ArrayList;

public class Solution {
	public static int dirX[] = { 0, 0, 1, -1 };
	public static int dirY[] = { 1, -1, 0, 0 };

	private static boolean isValid(ArrayList> mat, int x, int y, int dx, int dy) {
		int n = mat.size();
		int m = mat.get(0).size();

		/*
		 * Check boundary conditions and if the next element is a greater element
		 */
		if (dx >= 0 && dx < n && dy >= 0 && dy < m && mat.get(dx).get(dy).intValue() > mat.get(x).get(y).intValue()) {
			return true;
		}

		return false;
	}

	private static int dfs(ArrayList> mat, ArrayList> dp, int x, int y) {
		// If the path has already been searched, return
		if (dp.get(x).get(y) != 0) {
			return dp.get(x).get(y);
		}

		// A single element forms an increasing path of length 1
		int len = 1;

		// Check along the 4 directions one by one
		for (int i = 0; i < 4; i++) {
			int dx = x + dirX[i];
			int dy = y + dirY[i];

			if (isValid(mat, x, y, dx, dy)) {
				int currLen = dfs(mat, dp, dx, dy) + 1;
				len = Math.max(currLen, len);
			}
		}

		dp.get(x).set(y, len);

		return len;
	}

	public static int longestIncreasingPath(ArrayList> mat, int n, int m) {
		int maxLen = 0;

		ArrayList> dp = new ArrayList>();
		for (int i = 0; i < n; i++) {
			ArrayList row = new ArrayList();
			for (int j = 0; j < m; j++) {
				row.add(0);
			}
			dp.add(row);
		}

		// Find longest increasing path starting from each cell
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				maxLen = Math.max(dfs(mat, dp, i, j), maxLen);
			}
		}

		return maxLen;
	}
}

C++ (g++ 5.4)

/*
    Time Complexity: O(N*M)
    Space Complexity: O(N*M)

    where 'N' and 'M' denote the number of rows and columns.
*/


vector dirX = {0, 0, 1, -1};
vector dirY = {1, -1, 0, 0};


bool isValid(vector> &mat, int x, int y, int dx, int dy)
{
    int n = mat.size();
    int m = mat[0].size();

    /*
     Check boundary conditions and if the next element 
     is a greater element
    */
    if (dx >= 0 && dx < n && dy >= 0 && dy < m && mat[dx][dy] > mat[x][y])
    {
        return true;
    }

    return false;
}


int dfs(vector> &mat, vector> &dp, int x, int y)
{
    // If the path has already been searched, return 
    if (dp[x][y] != 0)
    {
        return dp[x][y];
    }

    // A single element forms an increasing path of length 1
    int len = 1;

    // Check along the 4 directions one by one
    for (int i = 0; i < 4; i++)
    {
        int dx = x + dirX[i];
        int dy = y + dirY[i];

        if (isValid(mat, x, y, dx, dy))
        {
            int currLen = dfs(mat, dp, dx, dy) + 1;
            len = max(currLen, len);
        }
    }

    dp[x][y] = len;

    return len;
}


int longestIncreasingPath(vector > &mat, int n, int m)
{
    int maxLen = 0;

    vector> dp(n, vector(m, 0));

    // Find longest increasing path starting from each cell
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            maxLen = max(dfs(mat, dp, i, j), maxLen);
        }
    }

    return maxLen;
}

Python (3.5)

'''

    Time Complexity: O(N*M)

    Space Complexity: O(N*M)



    where N and M are the number of rows and columns.

'''





dirX = [0, 0, 1, -1]

dirY = [1, -1, 0, 0]





def isValid(MAT, x, y, dx, dy):



    n = len(MAT)

    m = len(MAT[0])



    '''

     Check boundary conditions and if the next element 

     is a greater element

    '''

    if dx >= 0 and dx < n and dy >= 0 and dy < m and MAT[dx][dy] > MAT[x][y]:

        return True



    return False





def dfs(MAT, dp, x, y):



    # If the path has already been searched, return 

    if dp[x][y] != 0:

        return dp[x][y]



    # A single element forms an increasing path of length 1

    len = 1



    # Check along the 4 directions one by one

    for i in range(4):



        dx = x + dirX[i]

        dy = y + dirY[i]



        if isValid(MAT, x, y, dx, dy):

            len = max(len, dfs(MAT, dp, dx, dy) + 1)



    dp[x][y] = len



    return len





def longestIncreasingPath(MAT, n, m):



    maxLen = 0



    dp = [[0] * m for i in range(n)]



    # Find longest increasing path starting from each cell

    for i in range(n):

        for j in range(m):



            maxLen = max(dfs(MAT, dp, i, j), maxLen)



    return maxLen