Grid Teleportation Traversal

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: 1

💡 Note: Start at (0,0) → move right to (0,1) which has portal 'A' → teleport to (2,2) which is the destination. Total: 1 move (teleportation doesn't count as a move).

example_2.py — Multiple Portals

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

› Output: 0

💡 Note: Start at (0,0) which has portal 'A' → teleport directly to (2,2) which is the destination. Total: 0 moves (teleportation doesn't count as a move).

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

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

✓ Optimized

⏱️ Time: N/A Space: N/A

Hash Map

⏱️ Time: N/A Space: N/A

BFS with State Tracking (Optimal)

⏱️ Time: O(m*n*2^k) Space: O(m*n*2^k)

Use breadth-first search where each state includes both the current position and the set of portals already used. This ensures we find the minimum moves while correctly handling portal usage constraints.

Brute Force DFS with Backtracking

⏱️ Time: O(4^(m*n)) Space: O(m*n)

Use depth-first search to explore all possible paths from start to end, trying every combination of portal usage. For each cell, try moving in 4 directions, and if it's a portal, try both using and not using it.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct TrieNode {
    struct TrieNode* children[26];
    int isWord;
} TrieNode;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)malloc(sizeof(TrieNode));
    node->isWord = 0;
    for (int i = 0; i < 26; i++) {
        node->children[i] = NULL;
    }
    return node;
}

int solution(char* text, char words[][100], int wordCount, int result[][2]) {
    TrieNode* root = createNode();
    
    // Build Trie
    for (int i = 0; i < wordCount; i++) {
        TrieNode* node = root;
        for (int j = 0; words[i][j]; j++) {
            int index = words[i][j] - 'a';
            if (!node->children[index]) {
                node->children[index] = createNode();
            }
            node = node->children[index];
        }
        node->isWord = 1;
    }
    
    int count = 0;
    int n = strlen(text);
    
    // For each starting position
    for (int i = 0; i < n; i++) {
        TrieNode* node = root;
        // Try to match words starting at position i
        for (int j = i; j < n; j++) {
            int index = text[j] - 'a';
            if (!node->children[index]) {
                break;
            }
            node = node->children[index];
            if (node->isWord) {
                result[count][0] = i;
                result[count][1] = j;
                count++;
            }
        }
    }
    
    // Simple bubble sort
    for (int i = 0; i < count - 1; i++) {
        for (int j = 0; j < count - i - 1; j++) {
            if (result[j][0] > result[j+1][0] || 
                (result[j][0] == result[j+1][0] && result[j][1] > result[j+1][1])) {
                int temp0 = result[j][0], temp1 = result[j][1];
                result[j][0] = result[j+1][0]; result[j][1] = result[j+1][1];
                result[j+1][0] = temp0; result[j+1][1] = temp1;
            }
        }
    }
    
    return count;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char text[1001];
    fgets(text, sizeof(text), stdin);
    text[strcspn(text, "\n")] = 0;
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    char words[100][100];
    int wordCount = 0;
    
    // Parse JSON array format ["word1","word2",...]
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++; // skip '['
        char* end = strrchr(line, ']');
        if (end) *end = '\0';
        
        char* token = strtok(ptr, ",");
        while (token && wordCount < 100) {
            // Remove quotes and whitespace
            while (*token == ' ' || *token == '"') token++;
            char* tokenEnd = token + strlen(token) - 1;
            while (tokenEnd > token && (*tokenEnd == ' ' || *tokenEnd == '"')) tokenEnd--;
            *(tokenEnd + 1) = '\0';
            
            strcpy(words[wordCount], token);
            wordCount++;
            token = strtok(NULL, ",");
        }
    }
    
    int result[10000][2];
    int count = solution(text, words, wordCount, result);
    
    printf("[");
    for (int i = 0; i < count; i++) {
        printf("[%d,%d]", result[i][0], result[i][1]);
        if (i < count - 1) printf(",");
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear 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