Merge branch 'master' into vf2_graph_isomorphism

Author: ArpitaHanjagi

graph_algorithms/a_star_search.r

@@ -0,0 +1,237 @@
+# A* (A-star) Search Algorithm
+#
+# A* finds the least-cost path from a start node to a target node in a weighted graph.
+# It combines the path cost from the start (g-score) with a heuristic estimate (h-score)
+# to the goal: f = g + h. With an admissible and consistent heuristic, A* is optimal.
+#
+# Time Complexity: O((V + E) log V) with a binary heap priority queue
+# Space Complexity: O(V)
+#
+# Graph Input: adjacency list like other files in this folder, where each entry is a list of
+#              edges with fields `vertex` and `weight`. Vertices are numeric indices.
+# Heuristic: a function h(v) that estimates the remaining cost from v to the goal. By default
+#            it is 0 for all vertices (A* reduces to Dijkstra).
+# Output: A list containing g_scores (distances), f_scores, predecessor, a found flag, and path.
+
+# ---------------------------
+# Priority queue (min-heap-ish) using data.frame for clarity (educational)
+# ---------------------------
+create_priority_queue <- function() {
+  list(
+    elements = data.frame(vertex = integer(0), f = numeric(0), g = numeric(0), h = numeric(0)),
+    size = 0
+  )
+}
+
+pq_insert <- function(pq, vertex, f, g, h) {
+  pq$elements <- rbind(pq$elements, data.frame(vertex = vertex, f = f, g = g, h = h))
+  pq$size <- pq$size + 1
+  pq
+}
+
+pq_extract_min <- function(pq) {
+  if (pq$size == 0) {
+    return(list(pq = pq, min_element = NULL))
+  }
+  min_idx <- which.min(pq$elements$f)
+  min_element <- pq$elements[min_idx, ]
+  pq$elements <- pq$elements[-min_idx, ]
+  pq$size <- pq$size - 1
+  list(pq = pq, min_element = min_element)
+}
+
+pq_is_empty <- function(pq) {
+  pq$size == 0
+}
+
+# ---------------------------
+# Main A* implementation over adjacency-list graph
+# ---------------------------
+a_star_search <- function(graph, start, goal, heuristic = function(v) 0) {
+  # Collect all vertices (numeric indices expected as in other files)
+  all_vertices <- unique(c(names(graph), unlist(lapply(graph, function(x) sapply(x, function(e) e$vertex)))))
+  all_vertices <- as.numeric(all_vertices)
+  num_vertices <- max(all_vertices)
+
+  # Initialize scores and bookkeeping
+  g_scores <- rep(Inf, num_vertices)   # cost from start
+  f_scores <- rep(Inf, num_vertices)   # g + h
+  predecessor <- rep(-1, num_vertices)
+  closed <- rep(FALSE, num_vertices)
+
+  g_scores[start] <- 0
+  f_scores[start] <- heuristic(start)
+
+  pq <- create_priority_queue()
+  pq <- pq_insert(pq, start, f_scores[start], g_scores[start], heuristic(start))
+
+  found <- FALSE
+
+  while (!pq_is_empty(pq)) {
+    res <- pq_extract_min(pq)
+    pq <- res$pq
+    current <- res$min_element
+    if (is.null(current)) break
+
+    u <- as.integer(current$vertex)
+    if (closed[u]) next
+
+    # If target popped, we're done
+    if (u == goal) {
+      found <- TRUE
+      break
+    }
+
+    closed[u] <- TRUE
+
+    # Explore neighbors
+    if (as.character(u) %in% names(graph)) {
+      for (edge in graph[[as.character(u)]]) {
+        v <- edge$vertex
+        w <- edge$weight
+
+        if (closed[v]) next
+
+        tentative_g <- g_scores[u] + w
+        if (tentative_g < g_scores[v]) {
+          predecessor[v] <- u
+          g_scores[v] <- tentative_g
+          f_scores[v] <- tentative_g + heuristic(v)
+          pq <- pq_insert(pq, v, f_scores[v], g_scores[v], heuristic(v))
+        }
+      }
+    }
+  }
+
+  # Build path if found or reachable
+  path <- NULL
+  if (is.finite(g_scores[goal])) {
+    found <- TRUE
+    path <- reconstruct_a_star_path(predecessor, start, goal)
+  }
+
+  list(
+    g_scores = g_scores,
+    f_scores = f_scores,
+    predecessor = predecessor,
+    found = found,
+    path = path
+  )
+}
+
+reconstruct_a_star_path <- function(predecessor, start, goal) {
+  path <- c()
+  cur <- goal
+  while (cur != -1) {
+    path <- c(cur, path)
+    if (cur == start) break
+    cur <- predecessor[cur]
+  }
+  path
+}
+
+# ---------------------------
+# Grid helpers (to mirror the provided Java example on a 2D grid)
+# ---------------------------
+# Convert a 2D grid (matrix with 1 as free cell, 0 as blocked) to an adjacency list graph
+# Returns: list(graph = adjacency_list, index_of = function(r,c) -> vertex, coords = data.frame(row,col))
+grid_to_graph <- function(grid) {
+  stopifnot(is.matrix(grid))
+  nrow_g <- nrow(grid)
+  ncol_g <- ncol(grid)
+
+  index_of <- function(r, c) {
+    # 1-based indexing for vertices
+    (r - 1) * ncol_g + c
+  }
+
+  coords <- data.frame(row = integer(), col = integer())
+  adj <- list()
+
+  dirs <- rbind(c(-1, 0), c(1, 0), c(0, -1), c(0, 1)) # up, down, left, right
+
+  for (r in 1:nrow_g) {
+    for (c in 1:ncol_g) {
+      v <- index_of(r, c)
+      coords[v, c("row", "col")] <- c(r, c)
+      if (grid[r, c] == 1) {
+        edges <- list()
+        for (k in 1:nrow(dirs)) {
+          nr <- r + dirs[k, 1]
+          nc <- c + dirs[k, 2]
+          if (nr >= 1 && nr <= nrow_g && nc >= 1 && nc <= ncol_g && grid[nr, nc] == 1) {
+            edges[[length(edges) + 1]] <- list(vertex = index_of(nr, nc), weight = 1)
+          }
+        }
+        adj[[as.character(v)]] <- edges
+      } else {
+        adj[[as.character(v)]] <- list()
+      }
+    }
+  }
+
+  list(graph = adj, index_of = index_of, coords = coords)
+}
+
+# Manhattan heuristic factory for grid graphs
+make_manhattan_heuristic <- function(goal_vertex, coords) {
+  function(v) {
+    dv <- coords[v, ]
+    dg <- coords[goal_vertex, ]
+    abs(dv$row - dg$row) + abs(dv$col - dg$col)
+  }
+}
+
+# ---------------------------
+# Example usage and tests
+# ---------------------------
+cat("=== A* (A-star) Search Algorithm ===\n")
+
+# Example 1: Grid-based example mirroring the provided Java snippet
+cat("\n-- Grid example (5x5, 4-neighborhood, Manhattan heuristic) --\n")
+grid <- matrix(
+  c(1, 1, 1, 1, 1,
+    0, 1, 0, 1, 0,
+    1, 1, 1, 1, 1,
+    1, 0, 0, 0, 1,
+    1, 1, 1, 1, 1),
+  nrow = 5, ncol = 5, byrow = TRUE
+)
+
+gg <- grid_to_graph(grid)
+start_rc <- c(1, 1)  # row, col (1-based)
+goal_rc  <- c(5, 5)
+start_v <- gg$index_of(start_rc[1], start_rc[2])
+goal_v  <- gg$index_of(goal_rc[1], goal_rc[2])
+h_manhattan <- make_manhattan_heuristic(goal_v, gg$coords)
+
+cat("Running A* from (", start_rc[1], ", ", start_rc[2], ") to (", goal_rc[1], ", ", goal_rc[2], ")\n", sep = "")
+astar_res <- a_star_search(gg$graph, start_v, goal_v, heuristic = h_manhattan)
+
+if (astar_res$found && !is.null(astar_res$path)) {
+  cat("Path found (as grid coordinates):\n")
+  for (v in astar_res$path) {
+    rc <- gg$coords[v, ]
+    cat("(", rc$row, ", ", rc$col, ")\n", sep = "")
+  }
+  cat("Total steps:", length(astar_res$path) - 1, "\n")
+} else {
+  cat("No path found!\n")
+}
+
+# Example 2: Generic adjacency list (A* with zero heuristic behaves like Dijkstra)
+cat("\n-- Adjacency list example (zero heuristic -> Dijkstra behavior) --\n")
+weighted_graph <- list(
+  "1" = list(list(vertex = 2, weight = 1), list(vertex = 3, weight = 4)),
+  "2" = list(list(vertex = 3, weight = 2), list(vertex = 4, weight = 5)),
+  "3" = list(list(vertex = 4, weight = 1)),
+  "4" = list()
+)
+
+start <- 1
+goal <- 4
+res2 <- a_star_search(weighted_graph, start, goal)
+if (res2$found) {
+  cat("Shortest path from", start, "to", goal, ": ", paste(res2$path, collapse = " -> "),
+      " (distance:", res2$g_scores[goal], ")\n", sep = "")
+}

graph_algorithms/bidirectional_bfs.r

@@ -0,0 +1,153 @@
+# ==============================================================
+# Bidirectional Breadth-First Search (BFS) Shortest Path Algorithm
+# ==============================================================
+#
+# Description:
+#   Finds the shortest path between a source and target in an
+#   unweighted graph using Bidirectional BFS.
+#
+# Time Complexity: O(b^(d/2)) — much faster than normal BFS O(b^d)
+# Space Complexity: O(V)
+#
+# Input:
+#   graph  - adjacency list (list of integer vectors)
+#   source - integer (starting vertex)
+#   target - integer (destination vertex)
+#
+# Output:
+#   A list containing:
+#       path       - vector of vertices representing the path
+#       distance   - number of edges in the shortest path
+#       found      - logical flag (TRUE if path found, else FALSE)
+#
+# Example usage at bottom of file.
+# ==============================================================
+
+bidirectional_bfs <- function(graph, source, target) {
+  if (source == target) {
+    return(list(path = c(source), distance = 0, found = TRUE))
+  }
+
+  # Initialize BFS from both ends
+  visited_from_source <- setNames(rep(FALSE, length(graph)), names(graph))
+  visited_from_target <- setNames(rep(FALSE, length(graph)), names(graph))
+  
+  parent_from_source <- rep(NA, length(graph))
+  parent_from_target <- rep(NA, length(graph))
+  
+  queue_source <- c(source)
+  queue_target <- c(target)
+  
+  visited_from_source[source] <- TRUE
+  visited_from_target[target] <- TRUE
+  
+  meeting_node <- NA
+  
+  # Function to check intersection
+  get_intersection <- function() {
+    common <- which(visited_from_source & visited_from_target)
+    if (length(common) > 0) return(common[1])
+    return(NA)
+  }
+  
+  # Main loop
+  while (length(queue_source) > 0 && length(queue_target) > 0) {
+    # Expand one level from source side
+    next_queue <- c()
+    for (u in queue_source) {
+      for (v in graph[[as.character(u)]]) {
+        if (!visited_from_source[v]) {
+          visited_from_source[v] <- TRUE
+          parent_from_source[v] <- u
+          next_queue <- c(next_queue, v)
+        }
+      }
+    }
+    queue_source <- next_queue
+    
+    # Check intersection
+    meeting_node <- get_intersection()
+    if (!is.na(meeting_node)) break
+    
+    # Expand one level from target side
+    next_queue <- c()
+    for (u in queue_target) {
+      for (v in graph[[as.character(u)]]) {
+        if (!visited_from_target[v]) {
+          visited_from_target[v] <- TRUE
+          parent_from_target[v] <- u
+          next_queue <- c(next_queue, v)
+        }
+      }
+    }
+    queue_target <- next_queue
+    
+    # Check intersection again
+    meeting_node <- get_intersection()
+    if (!is.na(meeting_node)) break
+  }
+  
+  if (is.na(meeting_node)) {
+    return(list(path = NULL, distance = Inf, found = FALSE))
+  }
+  
+  # Reconstruct path from source → meeting_node
+  path1 <- c()
+  node <- meeting_node
+  while (!is.na(node)) {
+    path1 <- c(node, path1)
+    node <- parent_from_source[node]
+  }
+  
+  # Reconstruct path from meeting_node → target
+  path2 <- c()
+  node <- parent_from_target[meeting_node]
+  while (!is.na(node)) {
+    path2 <- c(path2, node)
+    node <- parent_from_target[node]
+  }
+  
+  full_path <- c(path1, path2)
+  return(list(path = full_path, distance = length(full_path) - 1, found = TRUE))
+}
+
+# ==============================================================
+# Example Usage and Test
+# ==============================================================
+
+cat("=== Bidirectional BFS Shortest Path ===\n")
+
+# Example Graph (Unweighted)
+# 1 -- 2 -- 3
+#  |    |
+#  4 -- 5 -- 6
+
+graph <- list(
+  "1" = c(2, 4),
+  "2" = c(1, 3, 5),
+  "3" = c(2, 6),
+  "4" = c(1, 5),
+  "5" = c(2, 4, 6),
+  "6" = c(3, 5)
+)
+
+cat("Graph adjacency list:\n")
+for (v in names(graph)) {
+  cat("Vertex", v, "-> [", paste(graph[[v]], collapse = ", "), "]\n")
+}
+
+cat("\nRunning Bidirectional BFS from 1 to 6...\n")
+result <- bidirectional_bfs(graph, 1, 6)
+
+if (result$found) {
+  cat("Shortest Path Found!\n")
+  cat("Path:", paste(result$path, collapse = " -> "), "\n")
+  cat("Distance:", result$distance, "\n")
+} else {
+  cat("No path found between source and target.\n")
+}
+    return(list(
+        distances = distances,
+        predecessor = predecessor,
+        found = found
+    ))