Pasos mínimos para obtener 1 en el centro de una array binaria

Dada una array N * N donde N es impar con todos los valores 0 excepto por una sola celda que tiene el valor 1. La tarea es encontrar los mínimos movimientos posibles para llevar este 1 al centro de la array cuando en un solo movimiento, se pueden intercambiar dos filas consecutivas o dos columnas consecutivas.
Ejemplos: 
 

Entrada: mat[][] = { 
{0, 0, 1, 0, 0}, 
{0, 0, 0, 0, 0}, 
{0, 0, 0, 0, 0}, 
{0, 0, 0, 0, 0}, 
{0, 0, 0, 0, 0}} 
Salida: 2 
Operación 1: Intercambiar la primera y la segunda fila. 
Operación 2: Intercambiar la segunda y la tercera fila.
Entrada: mat[][] = { 
{0, 0, 0}, 
{0, 1, 0}, 
{0, 0, 0}} 
Salida: 0 
 

Acercarse: 
 

• Calcula la posición del centro de la array como (cI, cJ) = (⌊N / 2⌋, ⌊N / 2⌋) .
• Encuentre la posición del 1 en la array y guárdela en (oneI, oneJ) .
• Ahora, los movimientos mínimos posibles serán abs(cI – oneI) + abs(cJ – oneJ) .

A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
const int N = 5;
 
// Function to return the
// minimum moves required
int minMoves(int mat[N][N])
{
 
    // Center of the matrix
    int cI = N / 2, cJ = N / 2;
 
    // Find the position of the 1
    int oneI = 0, oneJ = 0;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            if (mat[i][j] == 1) {
                oneI = i;
                oneJ = j;
                break;
            }
        }
    }
 
    return (abs(cI - oneI) + abs(cJ - oneJ));
}
 
// Driver code
int main()
{
    int mat[N][N] = { { 0, 0, 0, 0, 0 },
                      { 0, 0, 0, 0, 0 },
                      { 0, 0, 0, 0, 0 },
                      { 0, 0, 0, 0, 0 },
                      { 0, 0, 1, 0, 0 } };
 
    cout << minMoves(mat);
 
    return 0;
}

// Java implementation of the approach
class GFG
{
 
static int N = 5;
 
// Function to return the
// minimum moves required
static int minMoves(int mat[][])
{
 
    // Center of the matrix
    int cI = N / 2, cJ = N / 2;
 
    // Find the position of the 1
    int oneI = 0, oneJ = 0;
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            if (mat[i][j] == 1)
            {
                oneI = i;
                oneJ = j;
                break;
            }
        }
    }
 
    return (Math.abs(cI - oneI) + Math.abs(cJ - oneJ));
}
 
// Driver code
public static void main(String[] args)
{
    int mat[][] = { { 0, 0, 0, 0, 0 },
                    { 0, 0, 0, 0, 0 },
                    { 0, 0, 0, 0, 0 },
                    { 0, 0, 0, 0, 0 },
                    { 0, 0, 1, 0, 0 } };
 
    System.out.print(minMoves(mat));
}
}
 
// This code is contributed by PrinciRaj1992

# Python3 implementation of the approach
N = 5
 
# Function to return the
# minimum moves required
def minMoves(mat):
 
    # Center of the matrix
    cI = N // 2
    cJ = N // 2
 
    # Find the position of the 1
    oneI = 0
    oneJ = 0
    for i in range(N):
        for j in range(N):
            if (mat[i][j] == 1):
                oneI = i
                oneJ = j
                break
 
    return (abs(cI - oneI) + abs(cJ - oneJ))
 
# Driver code
mat = [[0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [0, 0, 1, 0, 0]]
 
print(minMoves(mat))
 
# This code is contributed by Mohit Kumar

// C# implementation of the approach
using System;
 
class GFG
{
static int N = 5;
 
// Function to return the
// minimum moves required
static int minMoves(int [,]mat)
{
 
    // Center of the matrix
    int cI = N / 2, cJ = N / 2;
 
    // Find the position of the 1
    int oneI = 0, oneJ = 0;
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            if (mat[i, j] == 1)
            {
                oneI = i;
                oneJ = j;
                break;
            }
        }
    }
    return (Math.Abs(cI - oneI) +
            Math.Abs(cJ - oneJ));
}
 
// Driver code
public static void Main(String[] args)
{
    int [,]mat = {{ 0, 0, 0, 0, 0 },
                  { 0, 0, 0, 0, 0 },
                  { 0, 0, 0, 0, 0 },
                  { 0, 0, 0, 0, 0 },
                  { 0, 0, 1, 0, 0 }};
 
    Console.Write(minMoves(mat));
}
}
 
// This code is contributed by 29AjayKumar

<script>
 
// JavaScript implementation of the approach
 
const N = 5;
 
// Function to return the
// minimum moves required
function minMoves(mat)
{
 
    // Center of the matrix
    let cI = parseInt(N / 2), cJ = parseInt(N / 2);
 
    // Find the position of the 1
    let oneI = 0, oneJ = 0;
    for (let i = 0; i < N; i++) {
        for (let j = 0; j < N; j++) {
            if (mat[i][j] == 1) {
                oneI = i;
                oneJ = j;
                break;
            }
        }
    }
 
    return (Math.abs(cI - oneI) + Math.abs(cJ - oneJ));
}
 
// Driver code
    let mat = [ [ 0, 0, 0, 0, 0 ],
                      [ 0, 0, 0, 0, 0 ],
                      [ 0, 0, 0, 0, 0 ],
                      [ 0, 0, 0, 0, 0 ],
                      [ 0, 0, 1, 0, 0 ] ];
 
    document.write(minMoves(mat));
 
</script>

2