Breaking News: Grepper is joining You.com. Read the official announcement!

Island Counting Algorithm in a 2D Matrix using Depth-First Search

Confused Caiman answered on November 9, 2023 Popularity 1/10 Helpfulness 1/10

answer Island Counting Algorithm in a 2D Matrix using Depth-First Search

related Island Counting Algorithm in a 2D Matrix using Depth-First Search

Island Counting Algorithm in a 2D Matrix using Depth-First Search

Comment

// A function to check if a given cell (row, col) can
// be included in DFS
function isSafe(M, row, col, visited, ROW, COL) {
    // row number is in range, column number is in range
    // and value is 1 and not yet visited
    return (
        row >= 0 &&
        row < ROW &&
        col >= 0 &&
        col < COL &&
        M[row][col] == 1 &&
        !visited[row][col]
    );
}

// A utility function to do DFS for a 2D boolean matrix.
// It only considers the 8 neighbors as adjacent vertices
function DFS(M, row, col, visited, ROW, COL) {
    // These arrays are used to get row and column numbers
    // of 8 neighbors of a given cell
    let rowNbr = [-1, -1, -1, 0, 0, 1, 1, 1];
    let colNbr = [-1, 0, 1, -1, 1, -1, 0, 1];

    // Mark this cell as visited
    visited[row][col] = true;

    // Recur for all connected neighbours
    for (let k = 0; k < 8; ++k) {
        if (isSafe(M, row + rowNbr[k], col + colNbr[k], visited, ROW, COL)) {
            DFS(M, row + rowNbr[k], col + colNbr[k], visited, ROW, COL);
        }
    }
}

// The main function that returns count of islands in a given
// boolean 2D matrix
function countIslands(M, ROW, COL) {
    // Make a bool array to mark visited cells.
    // Initially all cells are unvisited
    let visited = new Array(ROW);
    for (let i = 0; i < ROW; i++) {
        visited[i] = new Array(COL);
    }
    for (let i = 0; i < ROW; i++) {
        for (let j = 0; j < COL; j++) {
            visited[i][j] = false;
        }
    }
    // Initialize count as 0 and traverse through all cells
    // of given matrix
    let count = 0;
    for (let i = 0; i < ROW; ++i) {
        for (let j = 0; j < COL; ++j) {
            if (M[i][j] == 1 && !visited[i][j]) {
                // value 1 is not
                // visited yet, then new island found, Visit all
                // cells in this island and increment island count
                DFS(M, i, j, visited, ROW, COL);
                count++;
            }
        }
    }
    return count;
}

// Driver method
let M = [
    [1, 1, 0, 0, 0],
    [0, 1, 0, 0, 1],
    [1, 0, 0, 1, 1],
    [0, 0, 0, 0, 0],
    [1, 0, 1, 0, 1]
];

// Get the number of rows and columns dynamically
let ROW = M.length;
let COL = M[0].length;

document.write("Number of islands is: " + countIslands(M, ROW, COL));

Popularity 1/10 Helpfulness 1/10 Language javascript

Source: chat.openai.com

Tags: 2d algorithm counting javascript matrix search using

Link to this answer
Share Copy Link

Contributed on Nov 09 2023

Confused Caiman

0 Answers Avg Quality 2/10

Closely Related Answers

Island Counting Algorithm in a 2D Matrix using Depth-First Search

Comment

// A function to check if a given cell (row, col) can
// be included in DFS
function isSafe(M, row, col, visited, ROW, COL) {
    // row number is in range, column number is in range
    // and value is 1 and not yet visited
    return (
        row >= 0 &&
        row < ROW &&
        col >= 0 &&
        col < COL &&
        M[row][col] == 1 &&
        !visited[row][col]
    );
}

// A utility function to do DFS for a 2D boolean matrix.
// It only considers the 8 neighbors as adjacent vertices
function DFS(M, row, col, visited, ROW, COL) {
    // These arrays are used to get row and column numbers
    // of 8 neighbors of a given cell
    let rowNbr = [-1, -1, -1, 0, 0, 1, 1, 1];
    let colNbr = [-1, 0, 1, -1, 1, -1, 0, 1];

    // Mark this cell as visited
    visited[row][col] = true;

    // Recur for all connected neighbours
    for (let k = 0; k < 8; ++k) {
        if (isSafe(M, row + rowNbr[k], col + colNbr[k], visited, ROW, COL)) {
            DFS(M, row + rowNbr[k], col + colNbr[k], visited, ROW, COL);
        }
    }
}

// The main function that returns count of islands in a given
// boolean 2D matrix
function countIslands(M, ROW, COL) {
    // Make a bool array to mark visited cells.
    // Initially all cells are unvisited
    let visited = new Array(ROW);
    for (let i = 0; i < ROW; i++) {
        visited[i] = new Array(COL);
    }
    for (let i = 0; i < ROW; i++) {
        for (let j = 0; j < COL; j++) {
            visited[i][j] = false;
        }
    }
    // Initialize count as 0 and traverse through all cells
    // of given matrix
    let count = 0;
    for (let i = 0; i < ROW; ++i) {
        for (let j = 0; j < COL; ++j) {
            if (M[i][j] == 1 && !visited[i][j]) {
                // value 1 is not
                // visited yet, then new island found, Visit all
                // cells in this island and increment island count
                DFS(M, i, j, visited, ROW, COL);
                count++;
            }
        }
    }
    return count;
}

// Driver method
let M = [
    [1, 1, 0, 0, 0],
    [0, 1, 0, 0, 1],
    [1, 0, 0, 1, 1],
    [0, 0, 0, 0, 0],
    [1, 0, 1, 0, 1]
];

// Get the number of rows and columns dynamically
let ROW = M.length;
let COL = M[0].length;

document.write("Number of islands is: " + countIslands(M, ROW, COL));

Popularity 1/10 Helpfulness 1/10 Language javascript

Source: chat.openai.com

Tags: counting javascript matrix search using 2d algorithm

Link to this answer
Share Copy Link

Contributed on Nov 09 2023

Confused Caiman

0 Answers Avg Quality 2/10

Island Counting Algorithm in a 2D Matrix using Depth-First Search

Contents

More Related Answers

Island Counting Algorithm in a 2D Matrix using Depth-First Search

Closely Related Answers

Island Counting Algorithm in a 2D Matrix using Depth-First Search

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.