Ambulance Rescuer

You must have encountered the ambulance siren many times when you are stuck in the traffic. Although everyone prays for the safety of the patient within the ambulance. Most people do not even know the challenges of an ambulance trip. This vehicle breezes through the traffic and takes a critically ill patient to the hospital on time to bring them out of danger.

🚦 Stuck in traffic

Time play a crucial role in ambulance services. A person's life is dependent on your arrival. One of the most common reasons for arriving late at the patient's house is because of being stuck in traffic. Traffic is not something that is in your control, agreed. Most people give way to the ambulance, but there are times when the ambulances get stuck in the traffic.

A short struggle of an Ambulance

🤔 Solution to Problem

As traffic is continously growing, It is becoming difficult for ambulance to reach at patient optimally and from patient to nearest hospital optimally. This project is called Ambulance Rescuer because it provides the shortest path between source and destination optimally and efficiently. Lives of dying patient inside the ambulance can be decreased by using this idea as whole in the world.

🤷🏼‍♂️ About This Project

Access the site a Google Chrome: https://tushardixit01.github.io/#

What are Pathfinding Algorithms?

Pathfinding algorithms are usually an attempt to solve the shortest path problem in graph theory. They try to find the best path given a starting point and ending point based on some predefined criteria.

Currently supported algorithms are:

Dijkstra's Algorithm (Weighted)
A* Search (Weighted)
Greedy (Weighted)
Breath First Search (Unweighted)
Depth First Search (Unweighted)

Meet the Algorithms

This application supports the following algorithms:

Dijkstra's Algorithm (weighted): the father of pathfinding algorithms; guarantees the shortest path

A Search* (weighted): arguably the best pathfinding algorithm; uses heuristics to guarantee the shortest path much faster than Dijkstra's Algorithm

Greedy Best-first Search (weighted): a faster, more heuristic-heavy version of A*; does not guarantee the shortest path

Breath-first Search (unweighted): a great algorithm; guarantees the shortest path

Depth-first Search (unweighted): a very bad algorithm for pathfinding; does not guarantee the shortest path

Why are they important?

Path finding algorithms are important because they are used in applications like google maps, satellite navigation systems, routing packets over the internet. The usage of pathfinding algorithms isn’t just limited to navigation systems. The overarching idea can be applied to other applications as well. The usage will become clearer as we talk about some examples and implementations of pathfinding algorithms.

Weighted v/s Unweighted Graphs

If edges in your graph have weights then your graph is said to be a weighted graph, if the edges do not have weights, the graph is said to be unweighted. A weight is a numerical value attached to each individual edge. In a weighted graph relationships between nodes have a magnitude and this magnitude is important to the relationship we’re studying.

⚡ TechStack Used

This section lists all the technologies that I used to built this project.

🚀 Getting Started

Prerequisites

Clone the repo

$ git clone --single-branch -b main https://github.com/TusharDixit01/Hackercamp-22-Innovaccer.git .

Install NPM packages
```
$ npm i
```
Start the server
```
$ npm start server.js
```

📁 File Structure

The file structure of the current project is structured as shown below:

my-app
    ├── public
    |       ├── browser
    |       |       ├──  animations
    |       |       ├──  mazeAlgorithms
    |       |       ├──  pathfindingAlgorithms
    |       |       ├──  board.js
    |       |       ├──  bundle.js
    |       |       ├──  getDistance.js
    |       |       ├──  node.js
    |       └── styling
    ├── index.html
    └── server.js

❤ About Me

Made with ❤ by Tushar Dixit.