Given a square matrix [][] of size N * N, containing elements from 1 to N * N. You have to traverse all the elements from 1 to N*N serial-wise, Formally starting from element 1 then 2, 3, and so on.. till N*N, the task is to return the minimum number of steps for traversing all the elements serial wise, If you can only go one step left, right, up, or down from the current position.
Examples:
Input: N = 1, matrix[][] = {{1}}
Output: 0
Explanation: The Matrix is of 1*1 dimension having only one element in it. We are at element 1 in starting then no further element is there for traversing. Therefore, the output is 0.Input: N = 3, Matrix:{ {1, 7, 9}, {2, 4, 8}, {3, 6, 5}}
Output: 12
Explanation: Let us define the cells of Matrix as 1-based indexing then the steps are as follows:
- First Element = 1 at cell (1, 1), current = (1, 1), Total Steps = 0
- Second Element = 2, Traverse from current to (2, 1), Total Steps = 1, current = (2, 1)
- Third Element = 3, Traverse from current to (3, 1), total steps = 2, current = (3, 1)
- Fourth Element = 4, Traverse from current to (2, 1) then (2, 2), Total Steps = 4, current = (2, 2)
- Fifth Element = 5, Traverse from current to (2, 3) then (3, 3), Total Steps = 6, current = (3, 3)
- Sixth Element = 6, Traverse from current to (3, 2), Total Steps = 7, current = (3, 2)
- Seventh Element = 7, Traverse from current to (2, 2) then (1, 2), Total Steps = 9, current = (1, 2)
- Eighth Element = 8, Traverse from current to (2, 2) then (3, 2), Total Steps = 11, current = (2, 3)
- Ninth Element = 9, Traverse from current to (1, 3), Total Steps = 12, current = (1, 3)
It can be verified that elements from 1 to 9 are traversed in 12 steps, Which are the minimum possible steps.
Approach: Implement the below idea to solve the problem:
The problem is observation based and can be solved by using some observation such that traversal can be done in the minimum number of operations. The problem can be used by making two temporary arrays.
Steps were taken to solve the problem:
- Create two temp arrays X[] and Y[] of size N * N + 1.
- Traverse on the Matrix using nested loops from i=0 to less than N and j=0 to less than N and follow the below-mentioned steps under the scope of the loop:
- Initialize temp variable equal to Matrix[i][j]
- initialize X[temp] = i
- initialize Y[temp] = j
- Create two variables prevX and prevY and initialize them equal to X[1] and Y[1] respectively.
- Create a variable Steps = 0.
- Run a loop from i = 2 to less than X.length and follow the below-mentioned steps under the scope of loop:
- steps += Math.abs(prevX – x[i]) + Math.abs(prevY – y[i])
- prevX = x[i]
- prevY = y[i]
- Print value of Steps.
Below is the Code to implement the approach:
// C++ code to implement the approach #include <bits/stdc++.h> using namespace std;
// Function to find minimum steps required static void Minimum_steps( int &n, vector<vector< int >> & matrix)
{ // Size for temporary arrays
int s = n*n + 1;
// First Temporary Array
int x[s];
// Second Temporary array
int y[s];
// Loop for traversing on Matrix and
// initializing both temp arrays
for ( int i = 0; i < n; i++) {
for ( int j = 0; j < n; j++) {
int temp = matrix[i][j];
x[temp] = i;
y[temp] = j;
}
}
// Approach for counting number of steps
int prevX = x[1];
int prevY = y[1];
int steps = 0;
for ( int i = 2; i < s; i++) {
steps += abs (prevX - x[i]) + abs (prevY - y[i]);
prevX = x[i];
prevY = y[i];
}
// Printing number of steps
cout<< steps << endl;
} // Driver function int main() {
// Input value of N
int n = 3;
// Input Matrix
vector<vector< int >>matrix = { { 1, 7, 9 }, { 2, 4, 8 }, { 3, 6, 5 } };
// Function call
Minimum_steps(n, matrix);
} |
// Java code for the above approach import java.io.*;
import java.util.*;
class Main {
// Driver code
public static void main(String args[])
{
// Input value of N
int n = 3 ;
// Input Matrix
int [][] matrix
= { { 1 , 7 , 9 }, { 2 , 4 , 8 }, { 3 , 6 , 5 } };
// Function call
Minimum_steps(n, matrix);
}
// Function to find minimum
// steps required
static void Minimum_steps( int n, int [][] matrix)
{
// First Temporary Array
int [] x = new int [n * n + 1 ];
// Second Temporary array
int [] y = new int [n * n + 1 ];
// Loop for traversing on Matrix and
// initializing both temp arrays
for ( int i = 0 ; i < n; i++) {
for ( int j = 0 ; j < n; j++) {
int temp = matrix[i][j];
x[temp] = i;
y[temp] = j;
}
}
// Approach for counting
// number of steps
int prevX = x[ 1 ];
int prevY = y[ 1 ];
int steps = 0 ;
for ( int i = 2 ; i < x.length; i++) {
steps += Math.abs(prevX - x[i])
+ Math.abs(prevY - y[i]);
prevX = x[i];
prevY = y[i];
}
// Printing number of steps
System.out.println(steps);
}
} |
using System;
using System.Collections.Generic;
class Program {
static void MinimumSteps( int n, int [][] matrix) {
int s = n * n + 1;
int [] x = new int [s];
int [] y = new int [s];
for ( int i = 0; i < n; i++) {
for ( int j = 0; j < n; j++) {
int temp = matrix[i][j];
x[temp] = i;
y[temp] = j;
}
}
int prevX = x[1];
int prevY = y[1];
int steps = 0;
for ( int i = 2; i < s; i++) {
steps += Math.Abs(prevX - x[i]) + Math.Abs(prevY - y[i]);
prevX = x[i];
prevY = y[i];
}
Console.WriteLine(steps);
}
static void Main( string [] args) {
int n = 3;
int [][] matrix = new int [][] {
new int [] { 1, 7, 9 },
new int [] { 2, 4, 8 },
new int [] { 3, 6, 5 }
};
MinimumSteps(n, matrix);
}
} |
function minimumSteps(n, matrix) {
let s = n * n + 1;
let x = Array(s).fill(0);
let y = Array(s).fill(0);
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
let temp = matrix[i][j];
x[temp] = i;
y[temp] = j;
}
}
let prevX = x[1];
let prevY = y[1];
let steps = 0;
for (let i = 2; i < s; i++) {
steps += Math.abs(prevX - x[i]) + Math.abs(prevY - y[i]);
prevX = x[i];
prevY = y[i];
} console.log(steps); } let n = 3; let matrix = [[1, 7, 9], [2, 4, 8], [3, 6, 5]]; minimumSteps(n, matrix); |
def minimum_steps(n, matrix):
s = n * n + 1
x = [ 0 ] * s
y = [ 0 ] * s
for i in range (n):
for j in range (n):
temp = matrix[i][j]
x[temp] = i
y[temp] = j
prevX = x[ 1 ]
prevY = y[ 1 ]
steps = 0
for i in range ( 2 , s):
steps + = abs (prevX - x[i]) + abs (prevY - y[i])
prevX = x[i]
prevY = y[i]
print (steps)
n = 3
matrix = [[ 1 , 7 , 9 ], [ 2 , 4 , 8 ], [ 3 , 6 , 5 ]]
minimum_steps(n, matrix) |
12
Time Complexity: O(N2)
Auxiliary Space: O(N)