A* Pathfinding - Problem

Implement the A* (A-star) pathfinding algorithm on a weighted grid to find the shortest path from a start position to a goal position.

The grid contains:
• 0 - walkable cells with cost 1
• 1 - obstacles (impassable)
• 2 - high-cost terrain with cost 5

Use Manhattan distance as the heuristic function: |x1 - x2| + |y1 - y2|

Return an array containing:
1. The minimum cost to reach the goal
2. The path as coordinates [x, y] from start to goal
3. All explored coordinates during the search

If no path exists, return [-1, [], []]

Input & Output

Example 1 — Basic Pathfinding

$ Input: grid = [[0,2,0,1],[0,0,2,0]], start = [0,1], goal = [3,1]

› Output: [6,[[0,1],[1,1],[2,1],[3,1]],[[0,1],[1,1],[2,1],[3,1]]]

💡 Note: Path from (0,1) to (3,1): cost 1+1+5+1 = 6 (high-cost terrain at (2,1) costs 5). A* finds optimal path efficiently.

Example 2 — Obstacle Avoidance

$ Input: grid = [[0,1,0],[0,1,0],[0,0,0]], start = [0,0], goal = [2,0]

› Output: [4,[[0,0],[0,1],[0,2],[1,2],[2,2],[2,1],[2,0]],[[0,0],[0,1],[0,2],[1,2],[2,2],[2,1],[2,0]]]

💡 Note: Must go around obstacle column. Path: down, right, up. Total cost: 6 moves × 1 = 6.

Example 3 — No Path Available

$ Input: grid = [[0,1],[1,0]], start = [0,0], goal = [1,1]

› Output: [-1,[],[[0,0]]]

💡 Note: Start and goal are separated by obstacles. No valid path exists, return -1 with explored cells.

Constraints

1 ≤ grid.length ≤ 100
1 ≤ grid[0].length ≤ 100
grid[i][j] ∈ {0, 1, 2}
0 ≤ start[0], goal[0] < grid[0].length
0 ≤ start[1], goal[1] < grid.length

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 Apple 28 f Meta 25

The A* algorithm combines Dijkstra's shortest path guarantee with heuristic guidance to efficiently find optimal paths. The key insight is using f(n) = g(n) + h(n) where g is actual cost and h is Manhattan distance heuristic. Best approach is A* with Manhattan heuristic. Time: O(V log V), Space: O(V)

Common Approaches

✓ A* Algorithm with Manhattan Heuristic

⏱️ Time: O(V log V) Space: O(V)

Use A* algorithm with Manhattan distance heuristic to efficiently find the shortest path. Prioritizes nodes with lowest f(n) = g(n) + h(n) where g is actual cost and h is Manhattan distance to goal.

Dijkstra's Algorithm (No Heuristic)

⏱️ Time: O(V log V) Space: O(V)

Use Dijkstra's algorithm which explores all possible paths uniformly. This is essentially A* with heuristic = 0, so it doesn't use goal information to guide the search.

A* Algorithm with Manhattan Heuristic — Algorithm Steps

Step 1: Initialize priority queue with start position, f-score = g + h
Step 2: Pop node with lowest f-score from queue
Step 3: Add neighbors with updated g-score and Manhattan heuristic
Step 4: Repeat until goal found, exploring fewer cells than Dijkstra

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with f-score = g-cost + Manhattan distance heuristic

Guided Exploration

Always explore cells with lowest f-score first

Smart Choices

Manhattan heuristic guides search toward goal efficiently

Optimal Result

Find shortest path while exploring fewer cells than Dijkstra

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <math.h>

#define MAX_SIZE 100
#define MAX_NODES 10000

typedef struct {
    int fScore, gScore;
    int x, y;
    int pathLen;
    int path[MAX_SIZE][2];
} Node;

typedef struct {
    Node nodes[MAX_NODES];
    int size;
} PriorityQueue;

int manhattanDistance(int x1, int y1, int x2, int y2) {
    return abs(x1 - x2) + abs(y1 - y2);
}

void pqPush(PriorityQueue* pq, Node node) {
    pq->nodes[pq->size] = node;
    int i = pq->size++;
    while (i > 0 && pq->nodes[(i-1)/2].fScore > pq->nodes[i].fScore) {
        Node temp = pq->nodes[i];
        pq->nodes[i] = pq->nodes[(i-1)/2];
        pq->nodes[(i-1)/2] = temp;
        i = (i-1)/2;
    }
}

Node pqPop(PriorityQueue* pq) {
    Node result = pq->nodes[0];
    pq->nodes[0] = pq->nodes[--pq->size];
    int i = 0;
    while (2*i+1 < pq->size) {
        int minChild = 2*i+1;
        if (2*i+2 < pq->size && pq->nodes[2*i+2].fScore < pq->nodes[minChild].fScore) {
            minChild = 2*i+2;
        }
        if (pq->nodes[i].fScore <= pq->nodes[minChild].fScore) break;
        Node temp = pq->nodes[i];
        pq->nodes[i] = pq->nodes[minChild];
        pq->nodes[minChild] = temp;
        i = minChild;
    }
    return result;
}

void solution(int grid[MAX_SIZE][MAX_SIZE], int rows, int cols, int start[2], int goal[2]) {
    if (grid[start[1]][start[0]] == 1 || grid[goal[1]][goal[0]] == 1) {
        printf("[-1,[],[]]
");
        return;
    }
    
    PriorityQueue pq = {0};
    int visited[MAX_SIZE][MAX_SIZE] = {0};
    int explored[MAX_SIZE*MAX_SIZE][2];
    int exploredCount = 0;
    
    Node initial = {0, 0, start[0], start[1], 1};
    initial.fScore = manhattanDistance(start[0], start[1], goal[0], goal[1]);
    initial.path[0][0] = start[0];
    initial.path[0][1] = start[1];
    pqPush(&pq, initial);
    
    int directions[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
    
    while (pq.size > 0) {
        Node current = pqPop(&pq);
        
        if (visited[current.y][current.x]) continue;
        
        visited[current.y][current.x] = 1;
        explored[exploredCount][0] = current.x;
        explored[exploredCount][1] = current.y;
        exploredCount++;
        
        if (current.x == goal[0] && current.y == goal[1]) {
            printf("[%d,[", current.gScore);
            for (int i = 0; i < current.pathLen; i++) {
                if (i > 0) printf(",");
                printf("[%d,%d]", current.path[i][0], current.path[i][1]);
            }
            printf("],[");
            for (int i = 0; i < exploredCount; i++) {
                if (i > 0) printf(",");
                printf("[%d,%d]", explored[i][0], explored[i][1]);
            }
            printf("]]
");
            return;
        }
        
        for (int d = 0; d < 4; d++) {
            int nx = current.x + directions[d][0];
            int ny = current.y + directions[d][1];
            
            if (nx >= 0 && nx < cols && ny >= 0 && ny < rows && !visited[ny][nx]) {
                if (grid[ny][nx] != 1) {
                    int cellCost = (grid[ny][nx] == 0) ? 1 : 5;
                    int newGScore = current.gScore + cellCost;
                    int hScore = manhattanDistance(nx, ny, goal[0], goal[1]);
                    int newFScore = newGScore + hScore;
                    Node newNode = {newFScore, newGScore, nx, ny, current.pathLen + 1};
                    memcpy(newNode.path, current.path, current.pathLen * 2 * sizeof(int));
                    newNode.path[current.pathLen][0] = nx;
                    newNode.path[current.pathLen][1] = ny;
                    pqPush(&pq, newNode);
                }
            }
        }
    }
    
    printf("[-1,[],[");
    for (int i = 0; i < exploredCount; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", explored[i][0], explored[i][1]);
    }
    printf("]]
");
}

int main() {
    int grid[MAX_SIZE][MAX_SIZE];
    int start[2], goal[2];
    int rows = 0, cols = 0;
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char* ptr = strchr(line, '[') + 1;
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            cols = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    grid[rows][cols++] = *ptr - '0';
                }
                ptr++;
            }
            rows++;
        }
        ptr++;
    }
    
    fgets(line, sizeof(line), stdin);
    sscanf(line, "[%d,%d]", &start[0], &start[1]);
    
    fgets(line, sizeof(line), stdin);
    sscanf(line, "[%d,%d]", &goal[0], &goal[1]);
    
    solution(grid, rows, cols, start, goal);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V log V)

Each cell processed once with priority queue operations, heuristic guides search efficiently

⚡ Linearithmic

Space Complexity

O(V)

Priority queue, visited set, and path storage require space proportional to vertices

✓ Linear Space

23.4K Views

Medium Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

A* Pathfinding - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

A* Algorithm with Manhattan Heuristic — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler