ਬਾਈਨਰੀ ਮੈਟ੍ਰਿਕਸ ਵਿੱਚ 1 ਹੋਣ ਵਾਲੇ ਨੇੜਲੇ ਸੈੱਲ ਦੀ ਦੂਰੀ  


ਮੁਸ਼ਕਲ ਪੱਧਰ ਹਾਰਡ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ Accenture ਐਮਾਜ਼ਾਨ ਹਨੀਵੈੱਲ ਐਚਐਸਬੀਸੀ ਹੁਲੁ ਟਵਿੱਟਰ
ਅਰੇ ਚੌੜਾਈ ਪਹਿਲੀ ਖੋਜ ਗਰਾਫ਼ ਮੈਟਰਿਕਸ ਕਤਾਰ

ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ  

ਸਮੱਸਿਆ "ਬਾਈਨਰੀ ਮੈਟ੍ਰਿਕਸ ਵਿੱਚ 1 ਰੱਖਣ ਵਾਲੇ ਨਜ਼ਦੀਕੀ ਸੈੱਲ ਦੀ ਦੂਰੀ" ਦੱਸਦੀ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਬਾਈਨਰੀ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ ਮੈਟਰਿਕਸ(ਸਿਰਫ 0s ਅਤੇ 1s ਵਾਲੇ) ਘੱਟੋ ਘੱਟ ਇੱਕ ਨਾਲ 1. ਮੈਟ੍ਰਿਕਸ ਦੇ ਸਾਰੇ ਤੱਤਾਂ ਲਈ ਬਾਈਨਰੀ ਮੈਟ੍ਰਿਕਸ ਵਿੱਚ 1 ਹੋਣ ਵਾਲੇ ਨੇੜਲੇ ਸੈੱਲ ਦੀ ਦੂਰੀ ਲੱਭੋ, ਇੱਥੇ ਦੋ ਸੈੱਲਾਂ (x1, y1) ਅਤੇ (x2, y2) ਵਿਚਕਾਰ ਦੂਰੀ ਹੈ ) ਹੈ | x2 - x1 | + | y2 - y1 |

ਉਦਾਹਰਨ  

{
{0, 1, 0}
{0, 0, 0}
{1, 0, 0}
}
{
{1, 0, 1}
{1, 1, 2}
{0, 1, 2}
}

ਕਥਾ: ਅਸੀਂ ਵੇਖ ਸਕਦੇ ਹਾਂ ਕਿ 1 ਵਾਲੇ ਸੈੱਲਾਂ ਦੇ ਨਤੀਜੇ ਵੱਜੋਂ ਮੈਟ੍ਰਿਕਸ ਵਿਚ 0 ਹੁੰਦੇ ਹਨ ਅਤੇ ਸੈੱਲ 1 ਤੋਂ 1 ਦੀ ਦੂਰੀ ਤੇ ਸੈੱਲ ਹੁੰਦੇ ਹਨ. ਇਨ੍ਹਾਂ ਸੈੱਲਾਂ ਵਿਚ 1 ਆਉਟਪੁੱਟ ਵਜੋਂ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਸੇ ਤਰ੍ਹਾਂ, ਹੋਰ ਸੈੱਲਾਂ ਲਈ ਦੂਰੀਆਂ ਦੀ ਗਣਨਾ ਕੀਤੀ ਗਈ ਹੈ.

{
{0, 0, 0}
{0, 0, 0}
{1, 0, 1}
}
{
{2, 3, 2}
{1, 2, 1}
{0, 1, 0}
}

ਭੋਰਾ ਪਹੁੰਚ  

ਮੈਟ੍ਰਿਕਸ ਦੇ ਹਰ ਤੱਤ ਲਈ, ਪੂਰੇ ਨੂੰ ਪਾਰ ਕਰੋ ਮੈਟਰਿਕਸ ਅਤੇ ਮੈਟਰਿਕਸ ਵਿੱਚ ਘੱਟੋ ਘੱਟ ਦੂਰੀ ਵਾਲਾ ਸੈੱਲ ਲੱਭੋ.

  1. ਅਰੇ ਮੈਟ੍ਰਿਕਸ ਦੇ ਅਕਾਰ ਦੇ ਆਰੇ ਦੇ ਐਰੇ ਅੰਸ ਬਣਾਓ. ਮੈਟ੍ਰਿਕਸ ਦੇ ਸਾਰੇ ਤੱਤਾਂ ਨੂੰ ਪਾਰ ਕਰਨ ਲਈ ਦੋ ਨੇਸਟਡ ਲੂਪ ਚਲਾਓ.
  2. ਮੈਟ੍ਰਿਕਸ ਦੇ ਹਰੇਕ ਤੱਤ ਲਈ, ਮੈਟ੍ਰਿਕਸ ਦੇ ਹਰੇਕ ਤੱਤ ਨੂੰ ਪਾਰ ਕਰਨ ਲਈ ਦੋ ਹੋਰ ਨੇਸਟਡ ਲੂਪ ਚਲਾਓ, ਆਉ ਇਸਨੂੰ ਮੌਜੂਦਾ ਤੱਤ ਦੇ ਰੂਪ ਵਿੱਚ ਕਰ ਸਕੀਏ. ਸਾਰੇ ਮੌਜੂਦਾ ਤੱਤਾਂ ਲਈ ਜੋ ਕਿ 1 ਹਨ, ਘੱਟੋ ਘੱਟ ਦੂਰੀ ਤੱਤ ਲੱਭੋ ਅਤੇ ਉਸ ਦੂਰੀ ਨੂੰ ਅੰਸ ਐਰੇ ਵਿੱਚ ਸਟੋਰ ਕਰੋ.
  3. ਅੰਸ ਐਰੇ ਪ੍ਰਿੰਟ ਕਰੋ
ਇਹ ਵੀ ਵੇਖੋ
ਇੱਕ ਕਤਾਰ ਦੇ ਪਹਿਲੇ K ਤੱਤਾਂ ਨੂੰ ਉਲਟ ਕਰਨਾ

ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ = ਓ (ਐਨ2 * ਮੀ2)
ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ = ਓ (ਐਨ * ਐਮ)
ਜਿੱਥੇ n ਅਤੇ m ਕ੍ਰਮਵਾਰ ਦਿੱਤੇ ਗਏ ਮੈਟ੍ਰਿਕਸ ਦੀਆਂ ਕਤਾਰਾਂ ਅਤੇ ਕਾਲਮ ਹਨ.

ਕਿਉਂਕਿ ਅਸੀਂ ਮੈਟ੍ਰਿਕਸ ਵਿਚਲੇ ਹਰੇਕ ਸੈੱਲ ਲਈ ਪੂਰੇ ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਪਾਰ ਕਰ ਰਹੇ ਹਾਂ. ਇਹ ਐਲਗੋਰਿਦਮ ਨੂੰ ਉੱਚ ਸਮੇਂ ਦੀ ਜਟਿਲਤਾ ਵਿੱਚ ਚਲਾਉਣ ਲਈ ਬਣਾਉਂਦਾ ਹੈ. ਸਪੇਸ ਗੁੰਝਲਤਾ ਸਿਰਫ ਆਉਟਪੁੱਟ ਨੂੰ ਸਟੋਰ ਕਰਨ ਨਾਲ ਹੈ, ਪਰ ਐਲਗੋਰਿਦਮ ਆਪਣੇ ਆਪ ਨੂੰ ਨਿਰੰਤਰ ਜਗ੍ਹਾ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਜੇ ਅਸੀ ਆਉਟਪੁਟ ਨੂੰ ਸਿੱਧਾ ਪ੍ਰਿੰਟ ਕਰਦੇ, ਤਾਂ ਇਹ ਸਪੇਸ ਪੇਚੀਦਗੀ ਵੀ ਘੱਟ ਹੋ ਜਾਂਦੀ.

ਕੋਡ

ਬਾਈਨਰੀ ਮੈਟ੍ਰਿਕਸ ਵਿੱਚ 1 ਰੱਖਦੇ ਨੇੜਲੇ ਸੈੱਲ ਦੀ ਦੂਰੀ ਲੱਭਣ ਲਈ ਜਾਵਾ ਕੋਡ

class DistanceOfNearestCellHaving1InABinaryMatrix {
    private static void minimumDistance(int[][] matrix) {
        int n = matrix.length;
        int m = matrix[0].length;

        int[][] ans = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                int minDist = Integer.MAX_VALUE;
                for (int x = 0; x < n; x++) {
                    for (int y = 0; y < m; y++) {
                        if (matrix[x][y] == 1) {
                            int dist = Math.abs(x - i) + Math.abs(y - j);
                            minDist = Math.min(minDist, dist);
                        }
                    }
                }
                ans[i][j] = minDist;
            }
        }

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                System.out.print(ans[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int matrix1[][] = new int[][]{
                {0, 1, 0},
                {0, 0, 0},
                {1, 0, 0}
        };
        minimumDistance(matrix1);

        int matrix2[][] = new int[][]{
                {0, 0, 0},
                {0, 0, 0},
                {1, 0, 1}
        };
        minimumDistance(matrix2);
    }
}
1 0 1 
1 1 2 
0 1 2 

2 3 2 
1 2 1 
0 1 0

ਬਾਇਨਰੀ ਮੈਟ੍ਰਿਕਸ ਵਿੱਚ 1 ਰੱਖਦੇ ਨੇੜਲੇ ਸੈੱਲ ਦੀ ਦੂਰੀ ਲੱਭਣ ਲਈ ਸੀ ++ ਕੋਡ

#include<bits/stdc++.h> 
using namespace std; 

void minimumDistance(vector<vector<int>> &matrix) {
    int n = matrix.size();
    int m = matrix[0].size();
    
    int ans[n][m];
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            int minDist = INT_MAX;
            for (int x = 0; x < n; x++) {
                for (int y = 0; y < m; y++) {
                    if (matrix[x][y] == 1) {
                        int dist = abs(x - i) + abs(y - j);
                        minDist = std::min(minDist, dist);
                    }
                }
            }
            ans[i][j] = minDist;
        }
    }
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
              cout<<ans[i][j]<<" ";
        }
        cout<<endl;
    }
    cout<<endl;
}

int main() {
    // Example 1
    vector<vector<int>> matrix1 = {
            {0, 1, 0},
            {0, 0, 0},
            {1, 0, 0}
    };
    minimumDistance(matrix1);

    // Example 2
    vector<vector<int>> matrix2 = {
            {0, 0, 0},
            {0, 0, 0},
            {1, 0, 1}
    };
    minimumDistance(matrix2);
    
    return 0;
}
1 0 1 
1 1 2 
0 1 2 

2 3 2 
1 2 1 
0 1 0

ਅਨੁਕੂਲ ਪਹੁੰਚ  

ਬਿਹਤਰ ਪਹੁੰਚ ਇਹ ਹੈ ਕਿ ਦਿੱਤੇ ਗਏ ਮੈਟ੍ਰਿਕਸ ਵਿਚਲੇ ਸਾਰੇ 1s ਤੋਂ ਸ਼ੁਰੂ ਹੋ ਰਹੇ ਬੀ.ਐੱਫ.ਐੱਸ. ਸਾਰੇ 1s ਦੀ ਦੂਰੀ ਜ਼ੀਰੋ ਹੈ ਅਤੇ ਸਾਰੇ ਨੇੜਲੇ ਲਈ ਘੱਟੋ ਘੱਟ ਦੂਰੀ ਇਸ ਤੋਂ ਇਕ ਹੋਰ ਹੈ.

  1. ਇੱਕ ਬਣਾਓ ਪੂਛ ਕੋਆਰਡੀਨੇਟਸ ਦੀ, ਜੋ ਕਿ ਇਕ ਐਲੀਮੈਂਟ ਦੇ (ਰੋ, ਕਾਲਮ) ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ. ਇੱਕ ਬਣਾਓ ਐਰੇ ਅਰੇ ਦੇ ਅਕਾਰ ਦੇ ਉਤਰ ਦੇ ਉਤਰ ਮੈਟਰਿਕਸ.
  2. ਮੈਟ੍ਰਿਕਸ ਦੇ ਸਾਰੇ ਤੱਤ ਨੂੰ ਪਾਰ ਕਰੋ ਅਤੇ ਤੱਤ ਦੇ ਨਿਰਦੇਸ਼ਾਂਕਾਂ ਨੂੰ ਧੱਕੋ ਜੋ ਕਤਾਰ ਵਿੱਚ ਹਨ.
  3. ਇੱਕ ਵੇਰੀਏਬਲ ਮਿਨੀਡੈਂਸ ਨੂੰ 0 ਦੇ ਤੌਰ ਤੇ ਸ਼ੁਰੂਆਤ ਕਰੋ. ਜਦੋਂ ਕਿ ਕਤਾਰ 4 ਅਤੇ 5 ਦੇ ਦੁਹਰਾਓ ਖਾਲੀ ਨਹੀਂ ਹੈ.
  4. ਇੱਕ ਕਤਾਰ ਦੇ ਅਕਾਰ ਦੇ ਰੂਪ ਵਿੱਚ ਇੱਕ ਵੇਰੀਏਬਲ ਆਕਾਰ ਅਰੰਭ ਕਰੋ. I ਲਈ ਇੱਕ ਲੂਪ ਚਲਾਓ ਆਕਾਰ ਤੋਂ 0 ਦੇ ਬਰਾਬਰ (ਸ਼ਾਮਲ ਨਹੀਂ). ਹਰ ਦੁਹਰਾਓ ਤੇ ਕਤਾਰ ਤੋਂ ਇਕ ਤੱਤ ਕੱ popੋ. ਉੱਤਰ [ਕਤਾਰ] [ਕੋਲ] ਨੂੰ ਮਿੰਨੀ ਦੂਰੀ ਵਜੋਂ ਸੈੱਟ ਕਰੋ, ਅਤੇ ਇਸ ਐਲੀਮੈਂਟ ਦੇ ਸਾਰੇ ਜਾਇਜ਼ ਆਸ ਪਾਸ ਜੋ ਮੈਟਰਿਕਸ ਐਰੇ ਵਿਚ 0 ਹਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਮੈਟ੍ਰਿਕਸ ਐਰੇ ਵਿਚ 1 ਦੇ ਤੌਰ ਤੇ ਸੈੱਟ ਕਰੋ.
  5. ਵਾਧਾ ਮਿੰਨੀ ਦੂਰੀ.
  6. ਅੰਸ ਐਰੇ ਪ੍ਰਿੰਟ ਕਰੋ
ਇਹ ਵੀ ਵੇਖੋ
ਅੰਤਰ ਅੰਤਰ ਲੀਟਕੋਡ ਹੱਲ਼ ਲੱਭੋ

ਗੁੰਝਲਤਾ ਐਨਲੇਸਿਸ

ਟਾਈਮ ਜਟਿਲਤਾ = ਓ (ਐਨ * ਐਮ)
ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ = ਓ (ਐਨ * ਐਮ)
ਜਿੱਥੇ n ਅਤੇ m ਕ੍ਰਮਵਾਰ ਦਿੱਤੇ ਗਏ ਮੈਟ੍ਰਿਕਸ ਦੀਆਂ ਕਤਾਰਾਂ ਅਤੇ ਕਾਲਮ ਹਨ.

ਐਲਗੋਰਿਦਮ ਗ੍ਰਾਫਾਂ ਲਈ ਬੀਐਫਐਸ ਨਾਲ ਬਹੁਤ ਮਿਲਦਾ ਜੁਲਦਾ ਹੈ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਸਿਰਫ ਓ (ਐਨ * ਐਮ) ਸਮਾਂ ਲਿਆ ਗਿਆ ਹੈ.

ਕਥਾ

ਉਦਾਹਰਣ 'ਤੇ ਗੌਰ ਕਰੋ,
{
{0, 1, 0
{0, 0, 0
{1, 0, 0
}

ਬਾਈਨਰੀ ਮੈਟ੍ਰਿਕਸ ਵਿੱਚ 1 ਹੋਣ ਵਾਲੇ ਨੇੜਲੇ ਸੈੱਲ ਦੀ ਦੂਰੀਪਿੰਨ

ਕੋਡ

ਜਾਵਾ ਕੋਡ ਇਕ ਬਾਈਨਰੀ ਮੈਟ੍ਰਿਕਸ ਵਿੱਚ 1 ਰੱਖਦੇ ਨੇੜਲੇ ਸੈੱਲ ਦੀ ਦੂਰੀ ਲੱਭਣ ਲਈ

import java.util.LinkedList;
import java.util.Queue;
class Optimal {
    private static void minimumDistance(int[][] matrix) {
        int n = matrix.length;
        int m = matrix[0].length;

        // create an array ans of size same as matrix array
        int ans[][] = new int[n][m];

        // create a queue of coordinates
        // push all the elements that are equals to 1 in the matrix array to the queue
        Queue<Coordinate> queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (matrix[i][j] == 1) {
                    queue.add(new Coordinate(i, j));
                }
            }
        }

        // initialize minDistance as 0
        int minDistance = 0;

        while (!queue.isEmpty()) {
            // initialize size as size of queue
            int size = queue.size();

            // Run a loop size times
            for (int i = 0; i < size; i++) {
                // remove an element from queue
                Coordinate curr = queue.poll();

                // ans to this coordinate is minDistance
                ans[curr.row][curr.col] = minDistance;

                // enqueue all the valid adjacent cells of curr that are equals to
                // 0 in the matrix array and set them as 1

                // left adjacent
                int leftRow = curr.row - 1;
                int leftCol = curr.col;
                if ((leftRow >= 0 && leftRow < n) && (leftCol >= 0 && leftCol < m)) {
                    if (matrix[leftRow][leftCol] == 0) {
                        queue.add(new Coordinate(leftRow, leftCol));
                        matrix[leftRow][leftCol] = 1;
                    }
                }

                // right adjacent
                int rightRow = curr.row + 1;
                int rightCol = curr.col;
                if ((rightRow >= 0 && rightRow < n) && (rightCol >= 0 && rightCol < m)) {
                    if (matrix[rightRow][rightCol] == 0) {
                        queue.add(new Coordinate(rightRow, rightCol));
                        matrix[rightRow][rightCol] = 1;
                    }
                }

                // up adjacent
                int upRow = curr.row;
                int upCol = curr.col + 1;
                if ((upRow >= 0 && upRow < n) && (upCol >= 0 && upCol < m)) {
                    if (matrix[upRow][upCol] == 0) {
                        queue.add(new Coordinate(upRow, upCol));
                        matrix[upRow][upCol] = 1;
                    }
                }

                // down adjacent
                int downRow = curr.row;
                int downCol = curr.col - 1;
                if ((downRow >= 0 && downRow < n) && (downCol >= 0 && downCol < m)) {
                    if (matrix[downRow][downCol] == 0) {
                        queue.add(new Coordinate(downRow, downCol));
                        matrix[downRow][downCol] = 1;
                    }
                }
            }

            // increment minimum distance
            minDistance++;
        }

        // print the elements of the ans array
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                System.out.print(ans[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // Example 1
        int matrix1[][] = new int[][]{
                {0, 1, 0},
                {0, 0, 0},
                {1, 0, 0}
        };
        minimumDistance(matrix1);

        // Example 2
        int matrix2[][] = new int[][]{
                {0, 0, 0},
                {0, 0, 0},
                {1, 0, 1}
        };
        minimumDistance(matrix2);
    }

    // class representing coordinates of a cell in matrix
    static class Coordinate {
        int row;
        int col;

        public Coordinate(int row, int col) {
            this.row = row;
            this.col = col;
        }
    }
}
1 0 1 
1 1 2 
0 1 2 

2 3 2 
1 2 1 
0 1 0

ਬਾਇਨਰੀ ਮੈਟ੍ਰਿਕਸ ਵਿੱਚ 1 ਰੱਖਦੇ ਨੇੜਲੇ ਸੈੱਲ ਦੀ ਦੂਰੀ ਲੱਭਣ ਲਈ ਸੀ ++ ਕੋਡ

#include<bits/stdc++.h> 
using namespace std; 

// class representing coordinates of a cell in matrix
class Coordinate {
    public:
    int row;
    int col;
    
    Coordinate(int r, int c) {
        row = r;
        col = c;
    }
};

void minimumDistance(vector<vector<int>> &matrix) {
    int n = matrix.size();
    int m = matrix[0].size();
    
    // create an array ans of size same as matrix array
    int ans[n][m];
    
    // create a queue of coordinates
    // push all the elements that are equals to 1 in the matrix array to the queue
    queue<Coordinate> q;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (matrix[i][j] == 1) {
                Coordinate coordinate(i, j);
                q.push(coordinate);
            }
        }
    }
    
    // initialize minDistance as 0
    int minDistance = 0;
    
    while (!q.empty()) {
        // initialize size as size of queue
        int size = q.size();
        
        // Run a loop size times
        for (int i = 0; i < size; i++) {
            // remove an element from queue
            Coordinate curr = q.front();
            q.pop();
            
            // ans to this coordinate is minDistance
            ans[curr.row][curr.col] = minDistance;
            
            // enqueue all the valid adjacent cells of curr that are equals to
            // 0 in the matrix array and set them as 1
            
            // left adjacent
            int leftRow = curr.row - 1;
            int leftCol = curr.col;
            if ((leftRow >= 0 && leftRow < n) && (leftCol >= 0 && leftCol < m)) {
                if (matrix[leftRow][leftCol] == 0) {
                    Coordinate cLeft(leftRow, leftCol);
                    q.push(cLeft);
                    matrix[leftRow][leftCol] = 1;
                }
            }
            
            // right adjacent
            int rightRow = curr.row + 1;
            int rightCol = curr.col;
            if ((rightRow >= 0 && rightRow < n) && (rightCol >= 0 && rightCol < m)) {
                if (matrix[rightRow][rightCol] == 0) {
                    Coordinate cRight(rightRow, rightCol);
                    q.push(cRight);
                    matrix[rightRow][rightCol] = 1;
                }
            }
            
            // up adjacent
            int upRow = curr.row;
            int upCol = curr.col + 1;
            if ((upRow >= 0 && upRow < n) && (upCol >= 0 && upCol < m)) {
                if (matrix[upRow][upCol] == 0) {
                    Coordinate cUp(upRow, upCol);
                    q.push(cUp);
                    matrix[upRow][upCol] = 1;
                }
            }
            
            // down adjacent
            int downRow = curr.row;
            int downCol = curr.col - 1;
            if ((downRow >= 0 && downRow < n) && (downCol >= 0 && downCol < m)) {
                if (matrix[downRow][downCol] == 0) {
                    Coordinate cDown(downRow, downCol);
                    q.push(cDown);
                    matrix[downRow][downCol] = 1;
                }
            }
        }
        
        // increment minimum distance
        minDistance++;
    }
    
    // print the elements of the ans array
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cout<<ans[i][j]<<" ";
        }
        cout<<endl;
    }
    cout<<endl;
}

int main() {
    // Example 1
    vector<vector<int>> matrix1 = {
            {0, 1, 0},
            {0, 0, 0},
            {1, 0, 0}
    };
    minimumDistance(matrix1);

    // Example 2
    vector<vector<int>> matrix2 = {
            {0, 0, 0},
            {0, 0, 0},
            {1, 0, 1}
    };
    minimumDistance(matrix2);
    
    return 0;
}
1 0 1 
1 1 2 
0 1 2 

2 3 2 
1 2 1 
0 1 0