Grid Teleportation Traversal - Practice Coding Problems

Grid Teleportation Traversal - Problem

Imagine you're a digital explorer navigating through a mystical 2D grid world filled with obstacles and magical teleportation portals! 🌟

You start at the top-left corner (0, 0) and need to reach the bottom-right corner in the minimum number of moves. The grid contains:

'.' - Empty cells you can walk through
'#' - Obstacles that block your path
'A'-'Z' - Magical teleportation portals that can instantly transport you!

Here's the exciting part: when you step on a portal letter for the first time, you can instantly teleport to any other cell with the same letter anywhere in the grid! Each portal type can only be used once during your journey.

Goal: Find the minimum number of moves to reach the destination, or return -1 if it's impossible.

Input & Output

example_1.py — Basic Grid with Portal

$ Input: [ ".A.", "#.#", "..A" ]

› Output: 4

💡 Note: Start at (0,0) → move right to (0,1) which has portal 'A' → teleport to (2,2) → move left to (2,1) → move left to (2,0). Total: 4 moves (teleportation doesn't count as a move, but we need 4 regular moves).

example_2.py — Multiple Portals

$ Input: [ "A.B", "...", "B.A" ]

› Output: 2

💡 Note: Start at (0,0) which has portal 'A' → teleport to (2,2) → move left to (2,1) → move left to (2,0). Total: 2 moves.

example_3.py — No Portal Needed

$ Input: [ "...", ".#.", "..." ]

› Output: 4

💡 Note: Simple path without using any portals: (0,0) → (0,1) → (0,2) → (1,2) → (2,2). Total: 4 moves.

Constraints

1 ≤ m, n ≤ 100
grid[i][j] is one of '.', '#', or an uppercase English letter
The starting cell (0, 0) and ending cell (m-1, n-1) are guaranteed to not be obstacles ('#')
Each portal letter can be used at most once during the journey
Teleportation does not count as a move

Visualization

Tap to expand

Understanding the Visualization

Map Exploration

Start at the entrance and identify all available portals and their destinations

State Tracking

Keep track of your current position AND which portals you've already used

BFS Search

Explore all possible moves level by level, ensuring shortest path

Portal Decision

At each portal, decide whether using it now leads to a better path

Key Takeaway

🎯 Key Insight: Use BFS with state tracking (position + used portals) to guarantee the shortest path while respecting portal usage constraints. Each portal creates a branching point in our search space!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses BFS with state tracking where each state represents both the current position and the set of portals already used. This ensures we find the minimum number of moves while correctly handling the constraint that each portal can only be used once. The key insight is treating (position, used_portals) as the complete state space for our search.

Common Approaches

Approach	Time	Space	Notes
✓ BFS with State Tracking (Optimal)	O(mn2^k)	O(mn2^k)	Use BFS to find shortest path while tracking position and used portals as state
Brute Force DFS with Backtracking	O(4^(m*n))	O(m*n)	Try every possible path using DFS with backtracking to explore all portal combinations

BFS with State Tracking (Optimal) — Algorithm Steps

Initialize BFS queue with starting position (0,0) and empty used portals set
For each state, try all 4 direction moves to adjacent valid cells
If current cell is an unused portal, try teleporting to all matching portals
Track visited states as (position, used_portals) to avoid cycles
Return moves when reaching destination, or -1 if queue becomes empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize BFS

Start with (0,0, no portals used)

Explore States

Add adjacent moves and portal teleportations

Track Portal Usage

Each state includes bitmask of used portals

Find Shortest Path

BFS guarantees minimum moves

Code -

solution.c — C

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

#define MAX_SIZE 100
#define MAX_QUEUE 10000
#define MAX_PORTALS 26

typedef struct {
    int x, y;
} Position;

typedef struct {
    Position positions[MAX_SIZE];
    int count;
} PortalList;

typedef struct {
    int x, y, moves, usedMask;
} State;

typedef struct {
    State states[MAX_QUEUE];
    int front, rear;
} Queue;

int m, n;
char grid[MAX_SIZE][MAX_SIZE];
PortalList portals[MAX_PORTALS];
int directions[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};

void initQueue(Queue* q) {
    q->front = q->rear = 0;
}

int isEmpty(Queue* q) {
    return q->front == q->rear;
}

void enqueue(Queue* q, State s) {
    q->states[q->rear++] = s;
}

State dequeue(Queue* q) {
    return q->states[q->front++];
}

int minMovesToReach() {
    if (grid[0][0] == '#' || grid[m-1][n-1] == '#') {
        return -1;
    }
    
    // Initialize portals
    for (int i = 0; i < MAX_PORTALS; i++) {
        portals[i].count = 0;
    }
    
    // Find all portal positions
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] >= 'A' && grid[i][j] <= 'Z') {
                int portalIdx = grid[i][j] - 'A';
                portals[portalIdx].positions[portals[portalIdx].count].x = i;
                portals[portalIdx].positions[portals[portalIdx].count].y = j;
                portals[portalIdx].count++;
            }
        }
    }
    
    // BFS
    Queue q;
    initQueue(&q);
    enqueue(&q, (State){0, 0, 0, 0});
    
    // Simple visited tracking (limited)
    int visited[MAX_SIZE][MAX_SIZE] = {0};
    visited[0][0] = 1;
    
    while (!isEmpty(&q)) {
        State curr = dequeue(&q);
        
        if (curr.x == m-1 && curr.y == n-1) {
            return curr.moves;
        }
        
        // Try normal moves
        for (int i = 0; i < 4; i++) {
            int nx = curr.x + directions[i][0];
            int ny = curr.y + directions[i][1];
            if (nx >= 0 && nx < m && ny >= 0 && ny < n && 
                grid[nx][ny] != '#' && !visited[nx][ny]) {
                visited[nx][ny] = 1;
                enqueue(&q, (State){nx, ny, curr.moves + 1, curr.usedMask});
            }
        }
        
        // Try portal teleportation (simplified)
        char c = grid[curr.x][curr.y];
        if (c >= 'A' && c <= 'Z') {
            int portalIdx = c - 'A';
            if (!(curr.usedMask & (1 << portalIdx)) && portals[portalIdx].count > 0) {
                int newMask = curr.usedMask | (1 << portalIdx);
                for (int i = 0; i < portals[portalIdx].count; i++) {
                    int px = portals[portalIdx].positions[i].x;
                    int py = portals[portalIdx].positions[i].y;
                    if ((px != curr.x || py != curr.y) && !visited[px][py]) {
                        enqueue(&q, (State){px, py, curr.moves, newMask});
                    }
                }
            }
        }
    }
    
    return -1;
}

int main() {
    // Parse input - simplified version
    scanf("%d %d", &m, &n);
    for (int i = 0; i < m; i++) {
        scanf("%s", grid[i]);
    }
    
    printf("%d\n", minMovesToReach());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n*2^k)

Where k is number of unique portals. Each cell can be visited with different portal usage combinations, and there are 2^k possible portal states

✓ Linear Growth

Space Complexity

O(m*n*2^k)

BFS queue and visited set can contain up to m*n*2^k different states

⚡ Linearithmic Space

43.7K Views

High Frequency

~25 min Avg. Time

1.8K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS with State Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler