# Print all possible paths to escape out of a matrix from a given position using at most K moves

• Difficulty Level : Hard
• Last Updated : 20 Oct, 2021

Given a matrix mat[][] of dimension N*M, a positive integer K and the source cell (X, Y), the task is to print all possible paths to move out of the matrix from the source cell (X, Y) by moving in all four directions in each move in at most K moves.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: N = 2, M = 2, X = 1, Y = 1, K = 2
Output:
(1 1)(1 0)
(1 1)(1 2)(1 3)
(1 1)(1 2)(0 2)
(1 1)(0 1)
(1 1)(2 1)(2 0)
(1 1)(2 1)(3 1)

Input: N = 1, M = 1, X = 1, Y = 1, K = 2
Output:
(1 1)(1 0)
(1 1)(1 2)
(1 1)(0 1)
(1 1)(2 1)

Approach: The given problem can be solved by using Recursion and Backtracking. Follow the steps below to solve the given problem:

• Initialize an array, say, arrayOfMoves[] that stores all the moves moving from the source cell to the out of the matrix.
• Define a recursive function, say printAllmoves(N, M, moves, X, Y, arrayOfMoves), and perform the following steps:
• Base Case:
• If the value of the moves is non-negative and the current cell (X, Y) is out of the matrix, then print all the moves stored in the ArrayOfMoves[].
• If the value of moves is less than 0 then return from the function.
• Insert the current cell (X, Y) in the array arrayOfMoves[].
• Recursively call the function in all the four directions of the current cell (X, Y) by decrementing the value of moves by 1
• If the size of the array arrayOfMoves[] is greater than 1, then remove the last cell inserted for the Backtracking steps.
• Call the function printAllmoves(N, M, moves, X, Y, arrayOfMoves) to print all possible moves.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include``using` `namespace` `std;` `// Function to print all the paths``// that are outside of the matrix``void` `printAllmoves(``  ``int` `n, ``int` `m, ``int` `x, ``int` `y,``  ``int` `moves, vector> ArrayOfMoves)``{``  ` `  ``// Base Case``  ``if` `(x <= 0 || y <= 0 || x >= n + 1``      ``|| y >= m + 1 && moves >= 0) {` `    ``// Add the last position``    ``ArrayOfMoves.push_back({x, y});` `    ``// Traverse the pairs``    ``for` `(``auto` `ob : ArrayOfMoves) {` `      ``// Print all the paths``      ``cout<<``"("``< 1)``      ``ArrayOfMoves.pop_back();` `    ``return``;``  ``}` `  ``// If no moves remain``  ``if` `(moves <= 0) {``    ``return``;``  ``}` `  ``// Add the current position``  ``// in the list``  ``ArrayOfMoves.push_back({x, y});` `  ``// Recursive function Call``  ``// in all the four directions``  ``printAllmoves(n, m, x, y - 1, moves - 1,``                ``ArrayOfMoves);``  ``printAllmoves(n, m, x, y + 1, moves - 1,``                ``ArrayOfMoves);``  ``printAllmoves(n, m, x - 1, y, moves - 1,``                ``ArrayOfMoves);``  ``printAllmoves(n, m, x + 1, y, moves - 1,``                ``ArrayOfMoves);` `  ``// Backtracking Steps``  ``if` `(ArrayOfMoves.size() > 1) {``    ``ArrayOfMoves.pop_back();``  ``}``}` `// Driver Code``int` `main()``{``  ``int` `N = 2, M = 2;``  ``int` `X = 1;``  ``int` `Y = 1;``  ``int` `K = 2;``  ``vector> ArrayOfMoves;` `  ``// Function Call``  ``printAllmoves(N, M, X, Y, K,``                ``ArrayOfMoves);``}` `// This code is contributed by ipg2016107.`

## Java

 `// Java program for the above approach` `import` `java.io.*;``import` `java.util.*;` `public` `class` `GFG {` `    ``// Class for the pairs``    ``static` `class` `Pair {``        ``int` `a;``        ``int` `b;``        ``Pair(``int` `a, ``int` `b)``        ``{``            ``this``.a = a;``            ``this``.b = b;``        ``}``    ``}` `    ``// Function to print all the paths``    ``// that are outside of the matrix``    ``static` `void` `printAllmoves(``        ``int` `n, ``int` `m, ``int` `x, ``int` `y,``        ``int` `moves, ArrayList ArrayOfMoves)``    ``{``        ``// Base Case``        ``if` `(x <= ``0` `|| y <= ``0` `|| x >= n + ``1``            ``|| y >= m + ``1` `&& moves >= ``0``) {` `            ``// Add the last position``            ``ArrayOfMoves.add(``new` `Pair(x, y));` `            ``// Traverse the pairs``            ``for` `(Pair ob : ArrayOfMoves) {` `                ``// Print all the paths``                ``System.out.print(``"("` `+ ob.a``                                 ``+ ``" "` `+ ob.b``                                 ``+ ``")"``);``            ``}` `            ``System.out.println();` `            ``// Backtracking Steps``            ``if` `(ArrayOfMoves.size() > ``1``)``                ``ArrayOfMoves.remove(``                    ``ArrayOfMoves.size() - ``1``);` `            ``return``;``        ``}` `        ``// If no moves remain``        ``if` `(moves <= ``0``) {``            ``return``;``        ``}` `        ``// Add the current position``        ``// in the list``        ``ArrayOfMoves.add(``new` `Pair(x, y));` `        ``// Recursive function Call``        ``// in all the four directions``        ``printAllmoves(n, m, x, y - ``1``, moves - ``1``,``                      ``ArrayOfMoves);``        ``printAllmoves(n, m, x, y + ``1``, moves - ``1``,``                      ``ArrayOfMoves);``        ``printAllmoves(n, m, x - ``1``, y, moves - ``1``,``                      ``ArrayOfMoves);``        ``printAllmoves(n, m, x + ``1``, y, moves - ``1``,``                      ``ArrayOfMoves);` `        ``// Backtracking Steps``        ``if` `(ArrayOfMoves.size() > ``1``) {``            ``ArrayOfMoves.remove(``                ``ArrayOfMoves.size() - ``1``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``2``, M = ``2``;``        ``int` `X = ``1``;``        ``int` `Y = ``1``;``        ``int` `K = ``2``;``        ``ArrayList ArrayOfMoves``            ``= ``new` `ArrayList<>();` `        ``// Function Call``        ``printAllmoves(N, M, X, Y, K,``                      ``ArrayOfMoves);``    ``}``}`

## Python3

 `# Python program for the above approach` `# Function to print all the paths``# that are outside of the matrix``def` `printAllmoves(n,m,x,y, moves,ArrayOfMoves):``  ` `  ``# Base Case``  ``if` `(x <``=` `0` `or` `y <``=` `0` `or` `x >``=` `n ``+` `1` `or` `y >``=` `m ``+` `1` `and` `moves >``=` `0``):``    ` `    ``# Add the last position``    ``ArrayOfMoves.append([x, y])` `    ``# Traverse the pairs``    ``for` `ob ``in` `ArrayOfMoves:``      ` `      ``# Print all the paths``      ``print``(``"("``,ob[``0``],ob[``1``],``")"``,end``=``"")` `    ``print``(``"\n"``,end ``=` `"")` `    ``# Backtracking Steps``    ``if``(``len``(ArrayOfMoves) > ``1``):``      ``ArrayOfMoves.pop()` `    ``return` `  ``# If no moves remain``  ``if` `(moves <``=` `0``):``    ``return` `  ``# Add the current position``  ``# in the list``  ``ArrayOfMoves.append([x, y])` `  ``# Recursive function Call``  ``# in all the four directions``  ``printAllmoves(n, m, x, y ``-` `1``, moves ``-` `1``,ArrayOfMoves)``  ``printAllmoves(n, m, x, y ``+` `1``, moves ``-` `1``,ArrayOfMoves)``  ``printAllmoves(n, m, x ``-` `1``, y, moves ``-` `1``,ArrayOfMoves)``  ``printAllmoves(n, m, x ``+` `1``, y, moves ``-` `1``,ArrayOfMoves)` `  ``# Backtracking Steps``  ``if` `(``len``(ArrayOfMoves) > ``1``):``    ``ArrayOfMoves.pop()` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ``N ``=` `2``  ``M ``=` `2``  ``X ``=` `1``  ``Y ``=` `1``  ``K ``=` `2``  ``ArrayOfMoves ``=` `[]` `  ``# Function Call``  ``printAllmoves(N, M, X, Y, K,ArrayOfMoves)` `  ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `using` `System;``using` `System.Collections;``public` `class` `GFG {``    ``class` `Pair {``        ``public` `int` `a;``        ``public` `int` `b;``        ``public` `Pair(``int` `a, ``int` `b)``        ``{``            ``this``.a = a;``            ``this``.b = b;``        ``}``    ``}` `    ``// Function to print all the paths``    ``// that are outside of the matrix``    ``static` `void` `printAllmoves(``int` `n, ``int` `m, ``int` `x, ``int` `y,``                              ``int` `moves,``                              ``ArrayList ArrayOfMoves)``    ``{``        ``// Base Case``        ``if` `(x <= 0 || y <= 0 || x >= n + 1``            ``|| y >= m + 1 && moves >= 0) {` `            ``// Add the last position``            ``ArrayOfMoves.Add(``new` `Pair(x, y));` `            ``// Traverse the pairs``            ``foreach` `(Pair ob ``in` `ArrayOfMoves) {` `                ``// Print all the paths``                ``Console.Write(``"("` `+ ob.a + ``" "` `+ ob.b``                                  ``+ ``")"``);``            ``}` `            ``Console.WriteLine();` `            ``// Backtracking Steps``            ``if` `(ArrayOfMoves.Count > 1)``                ``ArrayOfMoves.Remove(ArrayOfMoves.Count``                                    ``- 1);` `            ``return``;``        ``}` `        ``// If no moves remain``        ``if` `(moves <= 0) {``            ``return``;``        ``}` `        ``// Add the current position``        ``// in the list``        ``ArrayOfMoves.Add(``new` `Pair(x, y));` `        ``// Recursive function Call``        ``// in all the four directions``        ``printAllmoves(n, m, x, y - 1, moves - 1,``                      ``ArrayOfMoves);``        ``printAllmoves(n, m, x, y + 1, moves - 1,``                      ``ArrayOfMoves);``        ``printAllmoves(n, m, x - 1, y, moves - 1,``                      ``ArrayOfMoves);``        ``printAllmoves(n, m, x + 1, y, moves - 1,``                      ``ArrayOfMoves);` `        ``// Backtracking Steps``        ``if` `(ArrayOfMoves.Count > 1) {``            ``ArrayOfMoves.Remove(ArrayOfMoves.Count - 1);``        ``}``    ``}``    ``static` `public` `void` `Main()``    ``{``        ``int` `N = 2, M = 2;``        ``int` `X = 1;``        ``int` `Y = 1;``        ``int` `K = 2;``        ``ArrayList ArrayOfMoves = ``new` `ArrayList();` `        ``// Function Call``        ``printAllmoves(N, M, X, Y, K, ArrayOfMoves);``    ``}``}` `// This code is contributed by maddler.`

## Javascript

 ``
Output:
```(1 1)(1 0)
(1 1)(1 2)(1 3)
(1 1)(1 2)(0 2)
(1 1)(0 1)
(1 1)(2 1)(2 0)
(1 1)(2 1)(3 1)```

Time Complexity: O(4N)
Auxiliary Space: O(4N)

My Personal Notes arrow_drop_up