New algorithms + visualizers

Author: cooperblacks

Graphs/sample-graph.json

@@ -0,0 +1,8 @@
+{
+  "A": ["B", "C"],
+  "B": ["A", "D", "E"],
+  "C": ["A", "F"],
+  "D": ["B"],
+  "E": ["B", "F"],
+  "F": ["C", "E"]
+}

Pathfinding/a-star.c

@@ -0,0 +1,119 @@
+// Algorithm: A* Search
+// Type: Graph, Pathfinding, Heuristic-based Search
+// Time Complexity: O(E) or O(V log V) with priority queue
+// Space Complexity: O(V)
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <limits.h>
+
+#define N 5  // Grid size
+#define INF 1000000
+
+typedef struct {
+    int x, y;
+} Point;
+
+typedef struct {
+    int f, g, h;
+    Point parent;
+    int visited;
+} Node;
+
+int dx[] = {-1, 1, 0, 0};
+int dy[] = {0, 0, -1, 1};
+
+// Heuristic: Manhattan distance
+int heuristic(Point a, Point b) {
+    return abs(a.x - b.x) + abs(a.y - b.y);
+}
+
+// Check if position is inside grid and not blocked
+int isValid(int grid[N][N], int x, int y) {
+    return x >= 0 && x < N && y >= 0 && y < N && grid[x][y] == 0;
+}
+
+// A* algorithm on grid
+void aStar(int grid[N][N], Point start, Point goal) {
+    Node nodes[N][N];
+
+    for (int i = 0; i < N; ++i)
+        for (int j = 0; j < N; ++j) {
+            nodes[i][j].f = INF;
+            nodes[i][j].g = INF;
+            nodes[i][j].h = 0;
+            nodes[i][j].visited = 0;
+            nodes[i][j].parent = (Point){-1, -1};
+        }
+
+    nodes[start.x][start.y].g = 0;
+    nodes[start.x][start.y].h = heuristic(start, goal);
+    nodes[start.x][start.y].f = nodes[start.x][start.y].h;
+
+    while (1) {
+        int minF = INF;
+        Point current = {-1, -1};
+
+        // Find node with lowest f
+        for (int i = 0; i < N; ++i)
+            for (int j = 0; j < N; ++j)
+                if (!nodes[i][j].visited && nodes[i][j].f < minF) {
+                    minF = nodes[i][j].f;
+                    current = (Point){i, j};
+                }
+
+        if (current.x == -1) {
+            printf("No path found\n");
+            return;
+        }
+
+        if (current.x == goal.x && current.y == goal.y) {
+            // Reconstruct path
+            printf("Path: ");
+            Point p = goal;
+            while (!(p.x == start.x && p.y == start.y)) {
+                printf("(%d,%d) <- ", p.x, p.y);
+                p = nodes[p.x][p.y].parent;
+            }
+            printf("(%d,%d)\n", start.x, start.y);
+            return;
+        }
+
+        nodes[current.x][current.y].visited = 1;
+
+        // Explore neighbors
+        for (int d = 0; d < 4; ++d) {
+            int nx = current.x + dx[d];
+            int ny = current.y + dy[d];
+
+            if (!isValid(grid, nx, ny) || nodes[nx][ny].visited) continue;
+
+            int tentativeG = nodes[current.x][current.y].g + 1;
+
+            if (tentativeG < nodes[nx][ny].g) {
+                nodes[nx][ny].parent = current;
+                nodes[nx][ny].g = tentativeG;
+                nodes[nx][ny].h = heuristic((Point){nx, ny}, goal);
+                nodes[nx][ny].f = tentativeG + nodes[nx][ny].h;
+            }
+        }
+    }
+}
+
+// Example usage
+int main() {
+    int grid[N][N] = {
+        {0, 1, 0, 0, 0},
+        {0, 1, 0, 1, 0},
+        {0, 0, 0, 1, 0},
+        {1, 1, 0, 0, 0},
+        {0, 0, 0, 1, 0}
+    };
+
+    Point start = {0, 0};
+    Point goal = {4, 4};
+
+    aStar(grid, start, goal);
+    return 0;
+}

Pathfinding/a-star.java

@@ -0,0 +1,53 @@
+// Algorithm: A* Search
+// Type: Graph, Pathfinding, Heuristic-based Search
+// Time Complexity: O(E)
+// Space Complexity: O(V)
+
+import java.util.*;
+
+public class AStar {
+    static class Node {
+        String name;
+        double f, g;
+
+        Node(String name, double g, double f) {
+            this.name = name; this.g = g; this.f = f;
+        }
+    }
+
+    public static List<String> aStar(Map<String, List<Map.Entry<String, Integer>>> graph,
+                                     String start, String goal,
+                                     Map<String, Integer> heuristic) {
+        PriorityQueue<Node> open = new PriorityQueue<>(Comparator.comparingDouble(n -> n.f));
+        Map<String, String> cameFrom = new HashMap<>();
+        Map<String, Double> gScore = new HashMap<>();
+
+        open.add(new Node(start, 0, heuristic.get(start)));
+        gScore.put(start, 0.0);
+
+        while (!open.isEmpty()) {
+            Node current = open.poll();
+
+            if (current.name.equals(goal)) {
+                LinkedList<String> path = new LinkedList<>();
+                while (cameFrom.containsKey(current.name)) {
+                    path.addFirst(current.name);
+                    current.name = cameFrom.get(current.name);
+                }
+                path.addFirst(start);
+                return path;
+            }
+
+            for (Map.Entry<String, Integer> neighbor : graph.get(current.name)) {
+                double tentative_g = gScore.get(current.name) + neighbor.getValue();
+                if (tentative_g < gScore.getOrDefault(neighbor.getKey(), Double.MAX_VALUE)) {
+                    cameFrom.put(neighbor.getKey(), current.name);
+                    gScore.put(neighbor.getKey(), tentative_g);
+                    double f = tentative_g + heuristic.get(neighbor.getKey());
+                    open.add(new Node(neighbor.getKey(), tentative_g, f));
+                }
+            }
+        }
+        return null;
+    }
+}

Pathfinding/a-star.js

@@ -0,0 +1,38 @@
+// Algorithm: A* Search
+// Type: Graph, Pathfinding, Heuristic-based Search
+// Time Complexity: O(E)
+// Space Complexity: O(V)
+
+function aStar(start, goal, graph, heuristic) {
+    const openSet = [[0, start]];
+    const cameFrom = {};
+    const gScore = { [start]: 0 };
+    const fScore = { [start]: heuristic(start, goal) };
+
+    while (openSet.length > 0) {
+        openSet.sort((a, b) => a[0] - b[0]);
+        const [_, current] = openSet.shift();
+
+        if (current === goal) {
+            const path = [];
+            let node = current;
+            while (cameFrom[node]) {
+                path.unshift(node);
+                node = cameFrom[node];
+            }
+            return [start, ...path];
+        }
+
+        for (const [neighbor, cost] of graph[current]) {
+            const tentative_g = gScore[current] + cost;
+            if (!(neighbor in gScore) || tentative_g < gScore[neighbor]) {
+                cameFrom[neighbor] = current;
+                gScore[neighbor] = tentative_g;
+                fScore[neighbor] = tentative_g + heuristic(neighbor, goal);
+                openSet.push([fScore[neighbor], neighbor]);
+            }
+        }
+    }
+
+    return null;
+}

Pathfinding/a-star.py

@@ -0,0 +1,32 @@
+# Algorithm: A* Search
+# Type: Graph, Pathfinding, Heuristic-based Search
+# Time Complexity: O(E)
+# Space Complexity: O(V)
+
+import heapq
+
+def a_star(start, goal, graph, heuristic):
+    open_set = [(0, start)]
+    came_from = {}
+    g_score = {start: 0}
+    f_score = {start: heuristic(start, goal)}
+
+    while open_set:
+        _, current = heapq.heappop(open_set)
+
+        if current == goal:
+            path = []
+            while current in came_from:
+                path.append(current)
+                current = came_from[current]
+            return path[::-1] + [goal]
+
+        for neighbor, cost in graph[current]:
+            tentative_g = g_score[current] + cost
+            if neighbor not in g_score or tentative_g < g_score[neighbor]:
+                came_from[neighbor] = current
+                g_score[neighbor] = tentative_g
+                f_score[neighbor] = tentative_g + heuristic(neighbor, goal)
+                heapq.heappush(open_set, (f_score[neighbor], neighbor))
+
+    return None

Pathfinding/a-star.txt

@@ -0,0 +1,32 @@
+// Algorithm: A* Search
+// Type: Graph, Pathfinding, Heuristic-based Search
+// Time Complexity: O(E), worst-case exponential depending on heuristic
+// Space Complexity: O(V)
+
+function AStar(start, goal, graph, heuristic):
+    openSet = PriorityQueue()
+    openSet.push(start, 0)
+    cameFrom = empty map
+
+    gScore = map with default ∞
+    gScore[start] = 0
+
+    fScore = map with default ∞
+    fScore[start] = heuristic(start, goal)
+
+    while openSet is not empty:
+        current = openSet.pop()
+
+        if current == goal:
+            return reconstruct_path(cameFrom, current)
+
+        for each neighbor of current:
+            tentative_gScore = gScore[current] + dist(current, neighbor)
+            if tentative_gScore < gScore[neighbor]:
+                cameFrom[neighbor] = current
+                gScore[neighbor] = tentative_gScore
+                fScore[neighbor] = gScore[neighbor] + heuristic(neighbor, goal)
+                if neighbor not in openSet:
+                    openSet.push(neighbor, fScore[neighbor])
+
+    return failure

Pathfinding/rapid-random-tree-star.java

@@ -0,0 +1,23 @@
+// Algorithm: RRT*
+// Type: Sampling-based Path Planning
+// Time: O(n log n), Space: O(n)
+
+class Node {
+    double x, y, cost;
+    Node parent;
+
+    Node(double x, double y) {
+        this.x = x; this.y = y; cost = 0;
+    }
+}
+
+double distance(Node a, Node b) {
+    return Math.hypot(a.x - b.x, a.y - b.y);
+}
+
+Node steer(Node from, Node to, double step) {
+    double dist = distance(from, to);
+    double theta = Math.atan2(to.y - from.y, to.x - from.x);
+    return new Node(from.x + step * Math.cos(theta),
+                    from.y + step * Math.sin(theta));
+}

Pathfinding/rapid-random-tree-star.js

@@ -0,0 +1,22 @@
+// Algorithm: RRT*
+// Type: Sampling-based Path Planning
+// Time: O(n log n), Space: O(n)
+
+class Node {
+    constructor(x, y, cost = 0, parent = null) {
+        this.x = x;
+        this.y = y;
+        this.cost = cost;
+        this.parent = parent;
+    }
+}
+
+function distance(a, b) {
+    return Math.hypot(a.x - b.x, a.y - b.y);
+}
+
+function steer(from, to, step = 1.0) {
+    const dist = distance(from, to);
+    const theta = Math.atan2(to.y - from.y, to.x - from.x);
+    return new Node(from.x + step * Math.cos(theta), from.y + step * Math.sin(theta), from.cost + step, from);
+}

Pathfinding/rapid-random-tree-star.py

@@ -0,0 +1,56 @@
+# Algorithm: RRT* (Rapidly-exploring Random Tree Star)
+# Type: Motion Planning, Sampling-based
+# Time Complexity: O(n log n)
+# Space Complexity: O(n)
+
+import random
+import math
+
+class Node:
+    def __init__(self, x, y):
+        self.x, self.y = x, y
+        self.parent = None
+        self.cost = 0
+
+def distance(a, b):
+    return math.hypot(a.x - b.x, a.y - b.y)
+
+def steer(from_node, to_node, step=1.0):
+    dist = distance(from_node, to_node)
+    if dist < step:
+        return Node(to_node.x, to_node.y)
+    theta = math.atan2(to_node.y - from_node.y, to_node.x - from_node.x)
+    return Node(from_node.x + step * math.cos(theta),
+                from_node.y + step * math.sin(theta))
+
+def rrt_star(start, goal, max_iter, map_bounds):
+    tree = [start]
+    for _ in range(max_iter):
+        x_rand = Node(random.uniform(0, map_bounds[0]), random.uniform(0, map_bounds[1]))
+        x_nearest = min(tree, key=lambda n: distance(n, x_rand))
+        x_new = steer(x_nearest, x_rand)
+
+        if not is_obstacle(x_nearest, x_new):
+            neighbors = [n for n in tree if distance(n, x_new) < 2.0]
+            x_min = x_nearest
+            c_min = x_nearest.cost + distance(x_nearest, x_new)
+
+            for n in neighbors:
+                if not is_obstacle(n, x_new) and n.cost + distance(n, x_new) < c_min:
+                    x_min = n
+                    c_min = n.cost + distance(n, x_new)
+
+            x_new.parent = x_min
+            x_new.cost = c_min
+            tree.append(x_new)
+
+            for n in neighbors:
+                if not is_obstacle(x_new, n) and x_new.cost + distance(x_new, n) < n.cost:
+                    n.parent = x_new
+                    n.cost = x_new.cost + distance(x_new, n)
+    
+    return extract_path(goal)
+
+# Dummy implementations
+def is_obstacle(a, b): return False
+def extract_path(goal): return []