added Graph algos - BFS/DFS, topological sort, cycle dection for both directed and undirected graphs and bi-partite graph detection

Author: kartikth40

Algorithms/kadane.js Algorithms/array/kadane.jsAlgorithms/kadane.js renamed to Algorithms/array/kadane.js

@@ -0,0 +1,69 @@
+// useful for shortest path in unweighted graph
+function bfs(start, graph) {
+  const q = new Queue()
+  q.push(start)
+  const visited = new Set([start])
+
+  while (!q.isEmpty()) {
+    const node = q.pop()
+    for (const nei of graph[node]) {
+      if (!visited.has(nei)) {
+        visited.add(nei)
+        q.push(nei)
+      }
+    }
+  }
+
+  return visited
+}
+
+
+// example usage:
+// shortest path in a grid with obstacles elimination
+class Cell {
+  constructor(row, col, remaining, distance) {
+    this.row = row
+    this.col = col
+    this.remaining = remaining
+    this.distance = distance
+  }
+}
+
+var shortestPath = function (grid, k) {
+  let m = grid.length
+  let n = grid[0].length
+
+  let q = new Queue()
+  q.push(new Cell(0, 0, k, 0))
+
+  let visited = new Set()
+  visited.add(`0,0,${k}`)
+
+  let directions = [
+    [0, 1],
+    [1, 0],
+    [0, -1],
+    [-1, 0],
+  ]
+
+  while (!q.isEmpty()) {
+    let cell = q.pop()
+    if (cell.row === m - 1 && cell.col === n - 1) return cell.distance
+
+    for (let [dr, dc] of directions) {
+      let newR = cell.row + dr
+      let newC = cell.col + dc
+
+      if (newR < 0 || newC < 0 || newR >= m || newC >= n) continue
+
+      let newRemaining = cell.remaining - grid[newR][newC]
+      let key = `${newR},${newC},${newRemaining}`
+      if (newRemaining >= 0 && !visited.has(key)) {
+        visited.add(key)
+        q.push(new Cell(newR, newC, newRemaining, cell.distance + 1))
+      }
+    }
+  }
+
+  return -1
+}

Algorithms/cycleDetectionDirected.js

@@ -0,0 +1,123 @@
+// BiPartite Graph Check using BFS
+
+/*
+  A bipartite graph is a graph whose vertices can be divided into two disjoint and independent 
+  sets U and V such that every edge connects a vertex in U to one in V. In other words, 
+  there are no edges between vertices within the same set.
+
+  Alternate coloring method can also be used to check bipartiteness.
+    - A graph is bipartite if and only if it contains NO odd-length cycles
+
+  Algorithm Steps:
+    1. Start coloring from an unvisited node, assign it one color (e.g., 0)
+    2. Use BFS to traverse the graph:
+        - Color all adjacent nodes with the alternate color (e.g., 1)
+        - If an adjacent node is already colored with the same color, return false
+    3. Repeat for all unvisited nodes to handle disconnected components
+    4. If no conflicts found, return true
+
+  Time Complexity: O(V + E) where V is vertices and E is edges
+  Space Complexity: O(V) for the color map and queue
+*/
+
+
+function isBipartite(graph) {
+  const nodes = Object.keys(graph)
+  let colors = {}
+
+  for(let node of nodes) {
+    node = parseInt(node)
+    colors[node] = -1 // -1 indicates uncolored
+  }
+
+  for(let nei of nodes) {
+    nei = parseInt(nei)
+    if(colors[nei] === -1 && !bfsCheck(nei)) {
+      return false
+    }
+  }
+
+  return true
+
+  function bfsCheck(start) {
+    const queue = [start]
+    colors[start] = 0 // Start coloring with color 0
+
+    while(queue.length > 0) {
+      const current = queue.shift()
+
+      for(let nei of graph[current]) {
+        if(colors[nei] === -1) {
+          colors[nei] = 1 - colors[current]
+          queue.push(nei)
+        }else if(colors[nei] === colors[current]) {
+          return false // Conflict in coloring
+        }
+      }
+    }
+    return true
+  }
+}
+
+const graph = { // Not Bipartite due to odd-length cycle
+  0: [1, 2],
+  1: [0, 3],
+  2: [0, 4],
+  3: [4, 1],
+  4: [3, 2],
+}
+
+const graph2 = { // Bipartite graph
+  0: [1, 2],
+  1: [0, 3],
+  2: [0, 4],
+  3: [5, 1],
+  4: [5, 2],
+  5: [3, 4]
+}
+
+console.log('Graph  - BFS:', isBipartite(graph)) // false
+console.log('Graph2 - BFS:', isBipartite(graph2)) // true
+
+/*
+  Questions to practice:
+  - Possible Bipartition - LeetCode (https://leetcode.com/problems/possible-bipartition/)
+*/
+
+
+// BiPartite Graph Check using DFS
+function isBipartiteDFS(graph) {
+  const nodes = Object.keys(graph)
+  let colors = {}
+
+  for(let node of nodes) {
+    node = parseInt(node)
+    colors[node] = -1 // -1 indicates uncolored
+  }
+
+  for(let nei of nodes) {
+    nei = parseInt(nei)
+    if(colors[nei] === -1 && !dfsCheck(nei, 0)) {
+      return false
+    }
+  }
+
+  return true
+
+  function dfsCheck(node, color) {
+    colors[node] = color
+
+    for(let nei of graph[node]) {
+      if(colors[nei] === -1 && !dfsCheck(nei, 1 - color)) {
+        return false
+      } else if(colors[nei] === colors[node]) {
+        return false
+      }
+    }
+
+    return true
+  }
+}
+
+console.log('Graph  - DFS:', isBipartiteDFS(graph)) // false
+console.log('Graph2 - DFS:', isBipartiteDFS(graph2)) // true

Algorithms/graph/bfs.js

@@ -0,0 +1,38 @@
+// Detect cycle in directed graph using DFS
+function hasCycle(graph) {
+
+  const visited = new Set()
+  const pathVisited = new Set() // Nodes currently in the recursion stack (current path)
+
+  function dfs(node) {
+    if (pathVisited.has(node)) return true // cycle found
+    if (visited.has(node)) return false // already processed, no cycle from this node
+
+    visited.add(node)
+    pathVisited.add(node)
+
+    for (const nei of graph[node]) {
+      if (dfs(nei)) return true // cyle found
+    }
+
+    pathVisited.delete(node)
+    return false // no cycle found from this node
+  }
+
+  for (let node in graph) {
+    node = parseInt(node) // Convert string (cause: for in loop) key to integer
+    if (!visited.has(node) && dfs(node)) return true
+  }
+
+  return false
+}
+
+const graph = {
+  0: [1],
+  1: [2],
+  2: [3],
+  3: [0, 4],
+  4: []
+}
+
+console.log(hasCycle(graph)) // true

Algorithms/graph/biPartite.js

@@ -0,0 +1,38 @@
+// Detect cycle in undirected graph using DFS
+function hasCycle(graph) {
+  const visited = new Set()
+  
+  // Check all nodes to handle disconnected components
+  for (let node in graph) {
+    node = parseInt(node) // Convert string (cause: for in loop) key to integer
+    if (!visited.has(node)) {
+      if (dfs(node, -1, visited, graph)) {
+        return true
+      }
+    }
+  }
+  return false
+
+  function dfs(node, parent, visited, graph) {
+    visited.add(node)
+
+    for (const neighbor of graph[node]) {
+      if (!visited.has(neighbor)) {
+        if (dfs(neighbor, node, visited, graph)) return true
+      } else if (neighbor !== parent) {
+        // Found a back edge - cycle detected
+        return true
+      }
+    }
+    return false
+  }
+}
+
+const graph = {
+  0: [1, 2],
+  1: [0, 3],
+  2: [0, 3],
+  3: [1, 2],
+}
+
+console.log(hasCycle(graph)) // true

Algorithms/graph/cycleDetectionDirected.js

@@ -0,0 +1,71 @@
+// useful for traversing all nodes in a graph depth-wise
+function dfs(node, graph, visited = new Set()) {
+  if (visited.has(node)) return
+  visited.add(node)
+ 
+  for (const nei of graph[node]) {
+    dfs(nei, graph, visited)
+  }
+}
+
+// example usage:
+// number of islands in a grid
+function numIslands(grid) {
+  let res = 0
+  let m = grid.length
+  let n = grid[0].length
+
+  let visited = Array.from({ length: m }, () => new Array(n).fill(false)) // m x n
+
+  let directions = [
+    [0, 1],
+    [1, 0],
+    [0, -1],
+    [-1, 0],
+  ]
+
+  function dfs(i, j) {
+    if (i < 0 || j < 0 || i >= m || j >= n || visited[i][j] || grid[i][j] === '0') return
+
+    visited[i][j] = true
+
+    for (let [dr, dc] of directions) {
+      let newR = i + dr
+      let newC = j + dc
+
+      dfs(newR, newC)
+    }
+  }
+
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      if (grid[i][j] === '1' && !visited[i][j]) {
+        res++
+        dfs(i, j)
+      }
+    }
+  }
+  return res
+}
+
+// example usage:
+// Get subtree size for each node in a tree
+function getSubtreeSizes(node, graph, visited = new Set(), sizes = {}) {
+  if (visited.has(node)) return 0
+  visited.add(node)
+  
+  let size = 1 // Count the current node
+  
+  for (const child of graph[node]) {
+    if (!visited.has(child)) {
+      const childSize = getSubtreeSizes(child, graph, visited, sizes)
+      size += childSize
+    }
+  }
+  
+  sizes[node] = size
+  return size
+}
+
+
+// bonus (bfs + dfs): Shortest Bridge Between Islands