Minimum moves taken to move coin of each cell to any one cell of Matrix
Given an odd number N which represents a grid of size N x N which is initially filled by coins, the task is to find the minimum number of moves required for all the coins to move to any cell of the grid such that in each step, some arbitrary coin in the middle of the grid can move to any of the surrounding eight cells.
Examples:
Input: N = 3
Output: 8
Explanation:
There are a total of 9 cells in a 3 x 3 grid. On assuming that all the coins have to be brought to the central cell, 8 coins should be moved and the number of steps is 8.
Input: N = 5
Output: 40
Approach: The minimum number of steps is obtained only when all the coins are moved to the centre of the grid. Therefore, the idea is to divide the entire grid into multiple layers.
- Each layer of the grid K takes K moves to reach to the centre. That is:
- The coins at layer 1 take one step to move to the centre.
- The coins at layer 2 take two steps to move to the centre and so on.
- For example, let N = 5. Then, the grid is divided into the layers as follows:
- In the above illustration, the coins which are marked in the red is at layer 1 and the coins which are marked blue is at layer 2.
- Similarly, for a grid of size N x N, we can divide the coins into N//2 layers.
- In each layer K, the number of coins present is (8 * K). And, the number of steps required is K. Therefore, iterate through all the layers and find the total number of steps as 8 * K2
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
int calculateMoves( int n)
{
int count = 0;
int layers = n / 2;
for ( int k = 1; k < layers + 1; k++)
{
count += 8 * k * k;
}
return count;
}
int main()
{
int N = 5;
cout << calculateMoves(N);
}
|
Java
import java.io.*;
class GFG{
public static int calculateMoves( int n)
{
int count = 0 ;
int layers = n / 2 ;
for ( int k = 1 ; k < layers + 1 ; k++)
{
count += 8 * k * k;
}
return count;
}
public static void main(String[] args)
{
int N = 5 ;
System.out.println(calculateMoves(N));
}
}
|
Python3
def calculateMoves(n):
count = 0
layers = n / / 2
for k in range ( 1 , layers + 1 ):
count + = 8 * k * k
return count
if __name__ = = "__main__" :
N = 5
print (calculateMoves(N))
|
C#
using System;
class GFG{
public static int calculateMoves( int n)
{
int count = 0;
int layers = n / 2;
for ( int k = 1; k < layers + 1; k++)
{
count += 8 * k * k;
}
return count;
}
public static void Main()
{
int N = 5;
Console.Write(calculateMoves(N));
}
}
|
Javascript
<script>
function calculateMoves(n)
{
var count = 0;
var layers = parseInt(n / 2);
for ( var k = 1; k < layers + 1; k++)
{
count += 8 * k * k;
}
return count;
}
var N = 5;
document.write(calculateMoves(N));
</script>
|
Time Complexity: O(N), as we are using a loop to traverse N times so it will cost us O(N) time
Auxiliary Space: O(1), as we are not using any extra space.
Last Updated :
15 Dec, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...