Count number of trees in a forest

<script>
// Javascript program to count number of trees in a forest.

// This class represents a directed graph 
// using adjacency list representation 
var V; // No. of vertices 

// Array of lists for 
// Adjacency List Representation 
var adj; 
// Constructor 
function Graph( v) 
{ 
    V = v; 
    adj = Array.from(Array(v), ()=>Array());
} 
// Function to add an edge into the graph 
function addEdge(v, w) 
{ 
    adj[v].push(w); // Add w to v's list. 
} 
// A function used by DFS 
function DFSUtil(v, visited) 
{ 
    // Mark the current node as 
    // visited and print it 
    visited[v] = true; 
    
    // Recur for all the vertices 
    // adjacent to this vertex 
    for(var i of adj[v]) 
    { 
        var n = i; 
        if (!visited[n])
        {
            DFSUtil(n, visited); 
        }
    }
} 
// The function to do DFS traversal.
// It uses recursive DFSUtil() 
function countTrees()
{ 
    // Mark all the vertices as not visited
    // (set as false by default in java) 
    var visited = Array(V).fill(false); 
    var res = 0;
    
    // Call the recursive helper function 
    // to print DFS traversal starting from 
    // all vertices one by one 
    for(var i = 0; i < V; ++i) 
    {
        if (visited[i] == false)
        { 
            DFSUtil(i, visited); 
            res ++;
        }
    }
    return res;
} 

// Driver code
Graph(5); 
addEdge(0, 1); 
addEdge(0, 2); 
addEdge(3, 4); 
document.write(countTrees()); 

// This code is contributed by rutvik_56.
</script>

// define a pair to represent a node in the forest
class Node {
    constructor(x, y) {
        this.x = x;
        this.y = y;
    }
}

// function to perform BFS from a given node and mark all visited nodes
function bfs(forest, start, visited) {
    // create a queue for BFS
    let q = [];
    q.push(start);
    visited[start.x][start.y] = true;

    // BFS loop
    while (q.length > 0) {
        let curr = q.shift();

        // add unvisited neighboring nodes to the queue
        let dx = [-1, 0, 1, 0];
        let dy = [0, 1, 0, -1];
        for (let i = 0; i < 4; i++) {
            let nx = curr.x + dx[i];
            let ny = curr.y + dy[i];
            if (nx >= 0 && nx < forest.length && ny >= 0 && ny < forest[0].length && forest[nx][ny] == 1 && !visited[nx][ny]) {
                q.push(new Node(nx, ny));
                visited[nx][ny] = true;
            }
        }
    }
}

// function to count the number of trees in a forest using BFS
function count_trees_in_forest(forest) {
    let count = 0;
    let n = forest.length;
    let m = forest[0].length;

    // create a 2D boolean array to keep track of visited nodes
    let visited = new Array(n);
    for (let i=0; i<n; i++) {
      visited[i] = new Array(m).fill(false);
    }

    // iterate over all nodes in the forest and perform BFS from each unvisited tree
    for (let i=0; i<n; i++) {
      for (let j=0; j<m; j++) {
          if (forest[i][j] == 1 && !visited[i][j]) {
              bfs(forest,new Node(i,j),visited);
              count++;
          }
      }
   }

   return count;
}

let forest=[
 [0 ,1 ,1 ,0 ,0],
 [0 ,0 ,0 ,0 ,0],
 [0, 0, 0, 0, 0],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 0]];
let num_trees = count_trees_in_forest(forest);
console.log("The forest has " + num_trees + " trees.");