Alphabet Board Path

Alphabet Board Path - Problem

On an alphabet board, we start at position (0, 0), corresponding to character board[0][0]. Here, board = ["abcde", "fghij", "klmno", "pqrst", "uvwxy", "z"], as shown in the diagram below.

We may make the following moves:

'U' moves our position up one row, if the position exists on the board
'D' moves our position down one row, if the position exists on the board
'L' moves our position left one column, if the position exists on the board
'R' moves our position right one column, if the position exists on the board
'!' adds the character board[r][c] at our current position (r, c) to the answer

Note: The only positions that exist on the board are positions with letters on them.

Return a sequence of moves that makes our answer equal to target in the minimum number of moves. You may return any path that does so.

Input & Output

Example 1 — Basic Navigation

$ Input: target = "leet"

› Output: "DDR!UURRR!!DDD!"

💡 Note: Start at 'a'(0,0). Go to 'l'(2,1): DD(down 2)R(right 1)!. Go to 'e'(0,4): UU(up 2)RRR(right 3)!. Go to 'e'(0,4): already there!. Go to 't'(3,4): DDD(down 3)!

Example 2 — Edge Case with 'z'

$ Input: target = "zdz"

› Output: "DDDDD!UUUURRR!DDDDD!"

💡 Note: Start at 'a'(0,0). Go to 'z'(5,0): DDDDD(down 5)!. Go to 'd'(0,3): UUUUU(up 5)RRR(right 3)!. Go to 'z'(5,0): DDDDD(down 5)!

Example 3 — Single Character

$ Input: target = "a"

› Output: "!"

💡 Note: Already at 'a'(0,0), just add '!' to collect the character

Constraints

1 ≤ target.length ≤ 100
target consists only of English lowercase letters.

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 15

The key insight is to use coordinate mapping with Manhattan distance calculation. Pre-compute each character's (row, col) position, then for each target character, calculate the direct path using row and column differences. Handle the 'z' edge case by moving up before left. Best approach uses Hash Map with Time: O(n), Space: O(1).

Common Approaches

✓ Sliding Window

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

Brute Force with BFS

⏱️ Time: O(n × 26²) Space: O(26)

For each character transition, use breadth-first search to explore all possible paths until we reach the target character, ensuring we find the minimum number of moves.

Hash Map with Coordinate Mapping

⏱️ Time: O(n) Space: O(1)

Build a hash map storing each character's (row, column) position on the board. For each character in target, look up coordinates and calculate the Manhattan distance path directly.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* colors, int n, int k) {
    if (k == 1) {
        return n;
    }
    
    // Find the length of the longest alternating sequence starting from each position
    int* altLengths = malloc(n * sizeof(int));
    
    // For each starting position, find how long the alternating sequence continues
    for (int start = 0; start < n; start++) {
        int length = 1;
        for (int i = 1; i < n; i++) {
            int currIdx = (start + i) % n;
            int prevIdx = (start + i - 1) % n;
            if (colors[currIdx] != colors[prevIdx]) {
                length++;
            } else {
                break;
            }
        }
        altLengths[start] = length;
    }
    
    // Count valid groups
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (altLengths[i] >= k) {
            // We can form a group of size k starting at position i
            count++;
        }
    }
    
    free(altLengths);
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int colors[1000];
    int n = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        colors[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(colors, n, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.0K Views

Medium Frequency

~15 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