A* Disaster Rescue Path Planning

1. Project Title

A* Disaster Rescue Path Planning

2. Overview

This project implements an A*-style path planning workflow for disaster-relief routing on a user-defined graph.
The system takes manually entered nodes, coordinates, and edge costs, then computes a traversal path from a chosen start node using cost (g) + heuristic (h) scoring.

From an engineering perspective, this project explores how to model a real-world rescue routing problem as a computational search problem with explicit state tracking (current node + visited elements) and heuristic guidance.

Why it matters: route planning under constraints is a core systems problem that appears in robotics, logistics, autonomous navigation, and AI planning pipelines.

3. Features

• Dynamic graph input through terminal prompts (nodes, coordinates, adjacency costs).
• Custom Node state representation with parent linkage for path reconstruction.
• Euclidean-distance heuristic over coordinate space.
• A* search loop with open/closed state management.
• Final path output as an ordered list of coordinates.
• Notebook-based implementation for experimentation and learning.

4. Tech Stack

• Python 3
• Jupyter Notebook
• Standard library: math
• Core concepts: graph search, heuristic optimization, state-space exploration

5. Architecture / Workflow

graph TD
A[User Inputs Graph and Coordinates] --> B[Build Graph Dictionary and Coordinate Map]
B --> C[Initialize Start Node State]
C --> D[Expand Successor States]
D --> E[Compute g h f Scores]
E --> F[Manage Open and Closed Collections]
F --> G[Iterate Until Search Exhausts]
G --> H[Backtrack via Parent Pointers]
H --> I[Output Coordinate Path]

Loading

6. Project Structure

Rescue-Disaster-AStar-PathPlanning/
|-- astar_path_finding.ipynb   # End-to-end implementation and execution flow
`-- README.md                  # Project documentation

7. Installation

This repository is notebook-first and uses Python standard library only.

git clone https://github.com/<your-username>/Rescue-Disaster-AStar-PathPlanning.git
cd Rescue-Disaster-AStar-PathPlanning

Optional (recommended) environment setup:

python -m venv .venv
# Windows
.venv\Scripts\activate
# Linux/macOS
source .venv/bin/activate
pip install notebook

8. Usage

1. Launch Jupyter:

jupyter notebook

2. Open astar_path_finding.ipynb.
3. Run cells in order.
4. Provide inputs when prompted:

• Number of nodes
• Node labels and coordinates
• Neighbor connections with costs
• Start point

The notebook prints:

Shortest path: [(x1, y1), (x2, y2), ...]

9. Example Output

Illustrative interaction pattern:

Enter the number of nodes: 4
Enter node label: A
Enter coordinates (x y) for node A: 0 0
...
Enter the start point: A
Shortest path: [(0, 0), (2, 1), (4, 3), (3, 5)]

10. Engineering Insights

• State design: search state is represented by current label and visited tracking, enabling constrained traversal behavior.
• Heuristic design: Euclidean distance provides an admissible-style geometric estimate in coordinate space.
• Reconstruction strategy: parent pointers allow deterministic backtracking of explored decisions.
• Computational profile: current open-list selection is linear scan (O(n) per selection), which is simple but not optimal.
• Scalability direction: replacing list-based frontier with a heap-based priority queue can improve runtime on larger graphs.

11. Learning Journey & AI/ML Foundations

A. Computational & Mathematical Foundations

This project reflects strong foundations in:

• Mathematical modeling of real-world routing constraints as graph problems
• Numerical computation through coordinate-based distance evaluation
• Computational equation solving in iterative search loops
• Algorithmic problem-solving using state-space exploration and cost functions
• Matrix-oriented thinking that aligns with NumPy-style computational workflows
• Structured data handling patterns conceptually aligned with Pandas-style processing

B. Current Academic Direction

I am currently pursuing an M.Tech in AI/ML.
My academic focus includes machine learning, deep learning, NLP, and AI systems engineering.

C. Self-Driven Learning Narrative

This repository is part of my self-driven transition into AI/ML engineering.
I actively build implementation-focused projects to convert theory into working systems and to strengthen practical skills across backend logic, algorithm design, and ML-adjacent engineering patterns.

D. Project -> AI/ML Mapping

• Graph search and constrained planning map directly to AI planning and autonomous decision systems.
• Numerical heuristics connect to optimization thinking used in ML training and inference pipelines.
• State modeling and traversal logic mirror how AI systems represent environments and actions.
• End-to-end input-processing-output workflow aligns with production AI pipeline design.
• Disaster-route simulation is conceptually adjacent to digital twin and predictive operational systems.

E. Narrative Positioning

This project is part of my transition into AI/ML, where I apply strong foundations in computational modeling and numerical methods to build scalable and intelligent systems.

F. Core Insight

Even before specializing in AI/ML, I was working with computational algorithms, numerical methods, and system modeling - which form the backbone of modern machine learning systems.

12. Challenges & Learnings

• Translating a real disaster-response narrative into a tractable computational graph model.
• Balancing heuristic guidance with explicit traversal constraints.
• Managing search-state representation so path reconstruction remains correct.
• Learning outcome: strong reinforcement of how algorithmic design decisions influence system behavior, efficiency, and extensibility.

13. Future Improvements

• Refactor notebook code into a modular Python package (src/, tests, CLI entrypoint).
• Replace linear open-list scan with heapq-based priority queue.
• Clarify and strengthen visited-edge semantics for stricter edge-coverage objectives.
• Add benchmark scenarios and complexity profiling for larger graphs.
• Extend toward AI/ML workflows with learnable or adaptive heuristics.
• Introduce data-driven risk weighting for route costs.
• Integrate with simulation environments for intelligent rescue planning.