Related Articles
Direction at last square block
• Difficulty Level : Hard
• Last Updated : 27 Feb, 2019

Given a R x C (1 <= R, C <= 1000000000) grid and initial position as top left corner and direction as east. Now we start running in forward direction and cross each square blocks of matrix. Whenever we find dead end or reach a cell that is already visited, we take right because we can not cross the visited square blocks again. Tell the direction when we will be at last square block.

For example : Consider the case with R = 3, C = 3. The path followed will be (0, 0) — (0, 1) — (0, 2) — (1, 2) — (2, 2) — (2, 1) — (2, 0) — (1, 0) — (1, 1). At this point, all squares have been visited, and is facing right.
Examples :

```Input  :  R = 1, C = 1
Output :  Right

Input   :  R = 2, C = 2
Output  :  Left

Input   :  R = 3, C = 1
Output  :  Down

Input  :  R = 3, C = 3
Output :  Right
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Simple Solution: One simple solution for this problem is to make it R x C matrix initialized with zero and traverse it in spiral form and take a variable ‘Dir’ that tells the current direction. Whenever we are at the end of any row and column take “Right” and change the value of ‘Dir’ according to your current direction. Now follow the given conditions :

• If you are traversing top row, then your current direction is “Right”.
• If you are right coloumn, then your current direction is “Down”.
• If you are traversing bottom row, then your current direction is “Left”.
• If you are traversing left coloumn, then your current direction is “Up”.

When we reach at the last square, just print current direction i.e; value of ‘Dir’ variable.
Time and space complexity for this problem is O(R x C) and this will work only for small values of R, C but here R and C are too large so creating R x C matrix is not possible for too large values of R and C.

Efficient Approach : This approach requires little observation and some pen paper work. Here we have to consider all the possible cases for R and C, then we just need to put IF condition for all the possible cases. Here we are with all the possible conditions :

1. R != C and R is even and C is odd and R<C, direction will be “Left”.
2. R != C and R is odd and C is even and R<C, direction will be “Right”.
3. R != C and R is even and C is even and R<C, direction will be “Left”.
4. R != C and R is odd and C is odd and R<C, direction will be “Right”.
5. R != C and R is even and C is odd and R>C, direction will be “Down”.
6. R != C and R is odd and C is even and R>C, direction will be “Up”.
7. R != C and R is even and C is even and R>C, direction will be “Up”.
8. R != C and R is odd and C is odd and R>C, direction will be “Down”.
9. R == C and R is even and C is even, direction will be “Left”.
10. R == C and R is odd and C is odd, direction will be “Right”.

Below is implementation of above idea.

## C++

 `// C++ program to tell the Current direction in ` `// R x C grid ` `#include ` `using` `namespace` `std; ` `typedef` `long` `long` `int` `ll; ` ` `  `// Function which tells the Current direction ` `void` `direction(ll R, ll C) ` `{ ` `    ``if` `(R != C && R % 2 == 0 && C % 2 != 0 && R < C) { ` `        ``cout << ``"Left"` `<< endl; ` `        ``return``; ` `    ``} ` `    ``if` `(R != C && R % 2 != 0 && C % 2 == 0 && R > C) { ` `        ``cout << ``"Up"` `<< endl; ` `        ``return``; ` `    ``} ` `    ``if` `(R == C && R % 2 != 0 && C % 2 != 0) { ` `        ``cout << ``"Right"` `<< endl; ` `        ``return``; ` `    ``} ` `    ``if` `(R == C && R % 2 == 0 && C % 2 == 0) { ` `        ``cout << ``"Left"` `<< endl; ` `        ``return``; ` `    ``} ` `    ``if` `(R != C && R % 2 != 0 && C % 2 != 0 && R < C) { ` `        ``cout << ``"Right"` `<< endl; ` `        ``return``; ` `    ``} ` `    ``if` `(R != C && R % 2 != 0 && C % 2 != 0 && R > C) { ` `        ``cout << ``"Down"` `<< endl; ` `        ``return``; ` `    ``} ` `    ``if` `(R != C && R % 2 == 0 && C % 2 == 0 && R < C) { ` `        ``cout << ``"Left"` `<< endl; ` `        ``return``; ` `    ``} ` `    ``if` `(R != C && R % 2 == 0 && C % 2 == 0 && R > C) { ` `        ``cout << ``"Up"` `<< endl; ` `        ``return``; ` `    ``} ` `    ``if` `(R != C && R % 2 == 0 && C % 2 != 0 && R > C) { ` `        ``cout << ``"Down"` `<< endl; ` `        ``return``; ` `    ``} ` `    ``if` `(R != C && R % 2 != 0 && C % 2 == 0 && R < C) { ` `        ``cout << ``"Right"` `<< endl; ` `        ``return``; ` `    ``} ` `} ` ` `  `// Driver program to test the Cases ` `int` `main() ` `{ ` `    ``ll R = 3, C = 1; ` `    ``direction(R, C); ` `    ``return` `0; ` `} `

## Java

 `// Java program to tell the Current direction in ` `// R x C grid ` `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `    ``// Function which tells the Current direction     ` `    ``static` `void` `direction(``int` `R, ``int` `C) ` `    ``{ ` `        ``if` `(R != C && R % ``2` `== ``0` `&& C % ``2` `!= ``0` `&& R < C) { ` `            ``System.out.println(``"Left"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R != C && R % ``2` `!= ``0` `&& C % ``2` `== ``0` `&& R > C) { ` `            ``System.out.println(``"Up"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R == C && R % ``2` `!= ``0` `&& C % ``2` `!= ``0``) { ` `            ``System.out.println(``"Right"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R == C && R % ``2` `== ``0` `&& C % ``2` `== ``0``) { ` `            ``System.out.println(``"Left"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R != C && R % ``2` `!= ``0` `&& C % ``2` `!= ``0` `&& R < C) { ` `            ``System.out.println(``"Right"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R != C && R % ``2` `!= ``0` `&& C % ``2` `!= ``0` `&& R > C) { ` `            ``System.out.println(``"Down"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R != C && R % ``2` `== ``0` `&& C % ``2` `== ``0` `&& R < C) { ` `            ``System.out.println(``"Left"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R != C && R % ``2` `== ``0` `&& C % ``2` `== ``0` `&& R > C) { ` `            ``System.out.println(``"Up"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R != C && R % ``2` `== ``0` `&& C % ``2` `!= ``0` `&& R > C) { ` `            ``System.out.println(``"Down"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R != C && R % ``2` `!= ``0` `&& C % ``2` `== ``0` `&& R < C) { ` `            ``System.out.println(``"Right"``); ` `            ``return``; ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `R = ``3``, C = ``1``; ` `         `  `        ``direction(R, C); ` `    ``} ` `} ` ` `  `// This code is contributed by KRV. `

## Python3

 `# Python3 program to tell the Current  ` `# direction in R x C grid ` ` `  `# Function which tells the Current direction ` `def` `direction(R, C): ` `    ``if` `(R !``=` `C ``and` `R ``%` `2` `=``=` `0` `and` `        ``C ``%` `2` `!``=` `0` `and` `R < C): ` `        ``print``(``"Left"``) ` `        ``return` ` `  `    ``if` `(R !``=` `C ``and` `R ``%` `2` `=``=` `0` `and`  `        ``C ``%` `2` `=``=` `0` `and` `R > C): ` `        ``print``(``"Up"``) ` `        ``return` ` `  `    ``if` `R ``=``=` `C ``and` `R ``%` `2` `!``=` `0` `and` `C ``%` `2` `!``=` `0``: ` `        ``print``(``"Right"``) ` `        ``return` ` `  `    ``if` `R ``=``=` `C ``and` `R ``%` `2` `=``=` `0` `and` `C ``%` `2` `=``=` `0``: ` `        ``print``(``"Left"``) ` `        ``return` ` `  `    ``if` `(R !``=` `C ``and` `R ``%` `2` `!``=` `0` `and`  `        ``C ``%` `2` `!``=` `0` `and` `R < C): ` `        ``print``(``"Right"``) ` `        ``return` ` `  `    ``if` `(R !``=` `C ``and` `R ``%` `2` `!``=` `0` `and`  `        ``C ``%` `2` `!``=` `0` `and` `R > C): ` `        ``print``(``"Down"``) ` `        ``return` ` `  `    ``if` `(R !``=` `C ``and` `R ``%` `2` `=``=` `0` `and`  `        ``C ``%` `2` `!``=` `0` `and` `R < C): ` `        ``print``(``"Left"``) ` `        ``return` ` `  `    ``if` `(R !``=` `C ``and` `R ``%` `2` `=``=` `0` `and`  `        ``C ``%` `2` `=``=` `0` `and` `R > C): ` `        ``print``(``"Up"``) ` `        ``return` ` `  `    ``if` `(R !``=` `C ``and` `R ``%` `2` `!``=` `0` `and`  `        ``C ``%` `2` `!``=` `0` `and` `R > C): ` `        ``print``(``"Down"``) ` `        ``return` ` `  `    ``if` `(R !``=` `C ``and` `R ``%` `2` `!``=` `0` `and`  `        ``C ``%` `2` `!``=` `0` `and` `R < C): ` `        ``print``(``"Right"``) ` `        ``return` ` `  `# Driver code ` `R ``=` `3``; C ``=` `1` `direction(R, C) ` ` `  `# This code is contributed by Shrikant13 `

## C#

 `// C# program to tell the Current ` `// direction in R x C grid ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `    ``// Function which tells  ` `    ``// the Current direction  ` `    ``static` `void` `direction(``int` `R, ``int` `C) ` `    ``{ ` `        ``if` `(R != C && R % 2 == 0 &&  ` `            ``C % 2 != 0 && R < C)  ` `        ``{ ` `            ``Console.WriteLine(``"Left"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R != C && R % 2 != 0 &&  ` `            ``C % 2 == 0 && R > C)  ` `        ``{ ` `            ``Console.WriteLine(``"Up"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R == C && R % 2 != 0 &&  ` `            ``C % 2 != 0)  ` `        ``{ ` `            ``Console.WriteLine(``"Right"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R == C && R % 2 == 0 &&  ` `            ``C % 2 == 0)  ` `        ``{ ` `            ``Console.WriteLine(``"Left"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R != C && R % 2 != 0 && ` `            ``C % 2 != 0 && R < C)  ` `        ``{ ` `            ``Console.WriteLine(``"Right"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R != C && R % 2 != 0 &&  ` `            ``C % 2 != 0 && R > C)  ` `        ``{ ` `            ``Console.WriteLine(``"Down"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R != C && R % 2 == 0 &&  ` `            ``C % 2 == 0 && R < C)  ` `        ``{ ` `            ``Console.WriteLine(``"Left"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R != C && R % 2 == 0 && ` `            ``C % 2 == 0 && R > C)  ` `        ``{ ` `            ``Console.WriteLine(``"Up"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R != C && R % 2 == 0 &&  ` `            ``C % 2 != 0 && R > C)  ` `        ``{ ` `            ``Console.WriteLine(``"Down"``); ` `            ``return``; ` `        ``} ` `        ``if` `(R != C && R % 2 != 0 &&  ` `            ``C % 2 == 0 && R < C)  ` `        ``{ ` `            ``Console.WriteLine(``"Right"``); ` `            ``return``; ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``static` `public` `void` `Main () ` `    ``{ ` `        ``int` `R = 3, C = 1; ` `         `  `        ``direction(R, C); ` `    ``} ` `} ` ` `  `// This code is contributed by m_kit `

## PHP

 ` ``\$C``)  ` `    ``{ ` `        ``echo` `"Up"` `,``"\n"``; ` `        ``return``; ` `    ``} ` `    ``if` `(``\$R` `== ``\$C` `&& ``\$R` `% 2 != 0  ` `                 ``&& ``\$C` `% 2 != 0)  ` `    ``{ ` `        ``echo` `"Right"` `,``"\n"``; ` `        ``return``; ` `    ``} ` `    ``if` `(``\$R` `== ``\$C` `&& ``\$R` `% 2 == 0  ` `                 ``&& ``\$C` `% 2 == 0)  ` `    ``{ ` `        ``echo` `"Left"` `,``"\n"``; ` `        ``return``; ` `    ``} ` `    ``if` `(``\$R` `!= ``\$C` `&& ``\$R` `% 2 != 0 &&  ` `                    ``\$C` `% 2 != 0 && ``\$R` `< ``\$C``)  ` `    ``{ ` `        ``echo` `"Right"` `,``"\n"``; ` `        ``return``; ` `    ``} ` `    ``if` `(``\$R` `!= ``\$C` `&& ``\$R` `% 2 != 0 &&  ` `                    ``\$C` `% 2 != 0 && ``\$R` `> ``\$C``)  ` `    ``{ ` `        ``echo` `"Down"` `,``"\n"``; ` `        ``return``; ` `    ``} ` `    ``if` `(``\$R` `!= ``\$C` `&& ``\$R` `% 2 == 0 &&  ` `                    ``\$C` `% 2 == 0 && ``\$R` `< ``\$C``)  ` `    ``{ ` `        ``echo` `"Left"` `,``"\n"``; ` `        ``return``; ` `    ``} ` `    ``if` `(``\$R` `!= ``\$C` `&& ``\$R` `% 2 == 0 &&  ` `                    ``\$C` `% 2 == 0 && ``\$R` `> ``\$C``) ` `    ``{ ` `        ``echo` `"Up"` `,``"\n"``; ` `        ``return``; ` `    ``} ` `    ``if` `(``\$R` `!= ``\$C` `&& ``\$R` `% 2 == 0 &&  ` `                    ``\$C` `% 2 != 0 && ``\$R` `> ``\$C``)  ` `    ``{ ` `        ``echo` `"Down"` `,``"\n"``; ` `        ``return``; ` `    ``} ` `    ``if` `(``\$R` `!= ``\$C` `&& ``\$R` `% 2 != 0 &&  ` `                    ``\$C` `% 2 == 0 && ``\$R` `< ``\$C``) ` `    ``{ ` `        ``echo` `"Right"` `,``"\n"``; ` `        ``return``; ` `    ``} ` `} ` ` `  `// Driver Code ` `\$R` `= 3; ``\$C` `= 1; ` `direction(``\$R``, ``\$C``); ` ` `  `// This code is contributed by aj_36 ` `?> `

Output :

``` Down
```

Time Complexity : O(1)
Auxiliary Space : O(1)

Reference: http://www.spoj.com/problems/TRGRID/