በሁለትዮሽ ማትሪክስ ውስጥ 1 ያለው የቅርቡ ሕዋስ ርቀት  


የችግር ደረጃ ጠንካራ
ውስጥ በተደጋጋሚ ተጠየቀ Accenture አማዞን Honeywell ኤችኤስቢሲ Hulu ትዊተር
ሰልፍ ስፌት የመጀመሪያ ፍለጋ ግራፍ ማትሪክስ ተራ

የችግሩ መግለጫ  

ችግሩ “በሁለትዮሽ ማትሪክስ ውስጥ 1 ያለው የቅርቡ ሕዋስ ርቀት” ሁለትዮሽ እንደተሰጠዎት ይናገራል ማትሪክስ(0 ዎችን እና 1 ዎችን ብቻ የያዘ) ቢያንስ ከአንድ ጋር 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. እነዚህ ህዋሳት እንደ XNUMX ውጤት አላቸው በተመሳሳይም ርቀቶች ለሌሎች ህዋሳት ተቆጥረዋል ፡፡

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

የዋህ አቀራረብ  

ለእያንዳንዱ የማትሪክስ አካል አጠቃላይውን ያቋርጡ ማትሪክስ እና በማትሪክስ ውስጥ 1 ርቀትን ቢያንስ ርቀት ያለው ሕዋስ ያግኙ ፡፡

  1. እንደ ድርድር ማትሪክስ ተመሳሳይ መጠን ያለው ድርድር አንስ ይፍጠሩ። ሁሉንም የማትሪክስ አካላት ለማቋረጥ ሁለት የጎጆ ቀለበቶችን ያሂዱ ፡፡
  2. በማትሪክስ ውስጥ ላሉት እያንዳንዱ ንጥረ ነገሮች እያንዳንዱን የማትሪክስ አካል ለማቋረጥ ሁለት ተጨማሪ የተጠለፉ ቀለበቶችን ያሂዱ ፣ እንደ አሁኑ ንጥረ ነገር ይህንን እናድርግ ፡፡ 1 ለ ላሉት የአሁኑ ክፍሎች ሁሉ አነስተኛውን የርቀት ክፍል ያግኙ እና ያንን ርቀት በ ‹አንሴ› ድርድር ውስጥ ያከማቹ ፡፡
  3. የአንሱን ድርድር ያትሙ።
ተመልከት
የአንድ ወረፋ የመጀመሪያ ኬ ንጥረ ነገሮችን መሻር

ውስብስብነት ትንተና

የጊዜ ውስብስብነት = ኦ (n2 * ሜ2)
የቦታ ውስብስብነት = ኦ (n * m)
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 ያለው የቅርቡ ሕዋስ ርቀት ለማግኘት C ++ ኮድ

#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

የተመቻቸ አቀራረብ  

በተሻለው ማትሪክስ ውስጥ ከሁሉም 1 ቶች ጀምሮ BFS ን ማከናወን የተሻለው አካሄድ ነው ፡፡ የሁሉም 1 ቶች ርቀት ዜሮ ሲሆን በአጠገብ ለሚገኘው ሁሉ ዝቅተኛው ርቀት ከዚህ የበለጠ አንድ ነው ፡፡

  1. ፍጠር ተራ የ ‹መጋጠሚያዎች› ፣ የአንድ ንጥረ ነገር (ረድፍ ፣ አምድ) ለማከማቸት የሚያገለግል ፡፡ ፍጠር አንድ ደርድር እንደ ድርድር መጠን ያላቸው አንሶች ማትሪክስ.
  2. በማትሪክስ ውስጥ ባሉ ሁሉም ነገሮች ውስጥ ተጓዙ እና 1 የሆኑትን ንጥረ ነገሮች መጋጠሚያዎች ወደ ወረፋው ይግፉ።
  3. ተለዋዋጭ minDistance ን እንደ 0. ያስጀምሩ ወረፋው ባዶ ባይሆንም 4 እና 5 ን ይድገሙ።
  4. እንደ ወረፋው መጠን አንድ ተለዋዋጭ መጠን ያስጀምሩ። ለ 0 እኩል መጠን ያለው ዙር ያሂዱ (አልተካተተም)። በእያንዳንዱ ድግግሞሽ ላይ ከወረፋው አንድ አካል ይወጣል። አንስ [ረድፍ] [ኮልን] እንደ ሚኒ ዲስትሬት አድርገው ያዘጋጁ እና በማትሪክስ ድርድር ውስጥ 0 የሆኑትን የዚህ ንጥረ ነገር ትክክለኛ ተጎራባቾች ሁሉ ያካብቱ እና በማትሪክስ ድርድር ውስጥ እንደ 1 ያዋቅሯቸው።
  5. ጭማሪ minDistance።
  6. የአንሱን ድርድር ያትሙ።
ተመልከት
የልዩ ኮድ መፍትሄውን ይፈልጉ

ውስብስብነት አናላይሲስ

የጊዜ ውስብስብነት = ኦ (n * m)
የቦታ ውስብስብነት = ኦ (n * m)
n እና m በቅደም ተከተል የተሰጠው ማትሪክስ ረድፎች እና አምዶች ያሉበት ቦታ።

አልጎሪዝም ለግራፎች ከ BFS ጋር በጣም ተመሳሳይ ነው እናም ስለሆነም O (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 ያለው የቅርቡ ሕዋስ ርቀት ለማግኘት C ++ ኮድ

#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