Minimum Distance to Type a Word Using Two Fingers

Minimum Distance to Type a Word Using Two Fingers - Problem

Imagine you're a speed typist using a special QWERTY keyboard arranged in a grid layout. Each uppercase letter A-Z is positioned at specific coordinates on a 2D plane:

'A' is at (0,0)
'B' is at (0,1)
'P' is at (2,3)
'Z' is at (4,1)

Here's the twist: you can only use TWO fingers to type! Your goal is to type a given word with the minimum total distance traveled by your fingers.

Distance calculation: Manhattan distance between coordinates (x1, y1) and (x2, y2) is |x1 - x2| + |y1 - y2|

Special rules:

Your fingers can start at any position for free (no initial cost)
You don't have to start typing with the first letter immediately
At each step, choose which finger to move to the next letter

Return: The minimum total distance to type the entire word.

Input & Output

example_1.py — Basic word typing

$ Input: word = "CAKE"

› Output: 7

💡 Note: One optimal strategy: Start finger1 at 'C' (free), finger2 at 'A' (free). Move finger1 from 'C' to 'K' (distance=3), move finger2 from 'A' to 'E' (distance=4). Total: 0 + 0 + 3 + 4 = 7

example_2.py — Single character

$ Input: word = "HAPPY"

› Output: 8

💡 Note: Start finger1 at 'H' (free), finger2 at 'A' (free). Move finger1 to 'P' (distance=2), move finger1 to 'P' (distance=0), move finger2 to 'Y' (distance=5). Total: 0+0+2+0+5=10. Alternative: finger1 at H->A->P->Y, finger2 at P costs 8.

example_3.py — Edge case single letter

$ Input: word = "NEW"

› Output: 3

💡 Note: Start finger1 at 'N' (free), finger2 at 'E' (free), then move finger1 from 'N' to 'W' (distance=3). Total distance is 3.

Constraints

2 ≤ word.length ≤ 300
word consists of uppercase English letters only
Each letter A-Z is positioned at coordinate ((ord(c) - ord('A')) // 6, (ord(c) - ord('A')) % 6)
Initial finger positions are free (cost = 0)

Visualization

Tap to expand

Asked in

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

The optimal solution uses dynamic programming with memoization to track the minimum cost for each state (current index, finger1 position, finger2 position). At each step, we decide whether to move finger1 or finger2 to the next letter, choosing the option that minimizes total distance. The key insight is that initial finger positions are free, so we can start optimally.

Common Approaches

✓ Dynamic Programming (Memoized Recursion)

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

This approach uses dynamic programming with memoization to optimize the brute force solution. We store results of subproblems in a cache to avoid redundant calculations. The state is defined by (current index, finger1 position, finger2 position).

Dynamic Programming (Memoized Recursion) — Algorithm Steps

Define state as (index, finger1_pos, finger2_pos)
For each state, try both options: move finger1 or finger2
Store results in memo table to avoid recalculation
Return minimum cost from both options

Visualization

Tap to expand

Step-by-Step Walkthrough

State Definition

Each state represents (index, finger1_pos, finger2_pos)

Memoization

Store results to avoid recalculating same states

Optimal Path

Build solution from optimal subproblems

Code -

solution.c — C

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

#define MAXN 1000
#define MAXMEMO 100000

typedef struct {
    int idx, f1, f2, result;
} MemoItem;

static MemoItem memo[MAXMEMO];
static int memoSize = 0;

typedef struct { int x, y; } Pos;

Pos getPos(char c) {
    int code = c - 'A';
    return (Pos){code / 6, code % 6};
}

int manhattanDist(Pos p1, Pos p2) {
    return abs(p1.x - p2.x) + abs(p1.y - p2.y);
}

int findMemo(int idx, int f1, int f2) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].idx == idx && memo[i].f1 == f1 && memo[i].f2 == f2) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int idx, int f1, int f2, int result) {
    if (memoSize < MAXMEMO) {
        memo[memoSize++] = (MemoItem){idx, f1, f2, result};
    }
}

int solve(char* word, int idx, int finger1, int finger2) {
    int len = strlen(word);
    if (idx == len) return 0;
    
    int cached = findMemo(idx, finger1, finger2);
    if (cached != -1) return cached;
    
    Pos currPos = getPos(word[idx]);
    int minCost = 1000000;
    
    // Option 1: Use finger 1
    int cost1 = finger1 ? manhattanDist(getPos(finger1), currPos) : 0;
    int result1 = cost1 + solve(word, idx + 1, word[idx], finger2);
    if (result1 < minCost) minCost = result1;
    
    // Option 2: Use finger 2
    int cost2 = finger2 ? manhattanDist(getPos(finger2), currPos) : 0;
    int result2 = cost2 + solve(word, idx + 1, finger1, word[idx]);
    if (result2 < minCost) minCost = result2;
    
    addMemo(idx, finger1, finger2, minCost);
    return minCost;
}

int main() {
    static char word[1000];
    if (fgets(word, sizeof(word), stdin) != NULL) {
        // Remove newline
        int len = strlen(word);
        if (len > 0 && word[len-1] == '\n') {
            word[len-1] = '\0';
        }
        printf("%d\n", solve(word, 0, 0, 0));
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 26^2)

n letters × 26 possible positions for finger1 × 26 possible positions for finger2

✓ Linear Growth

Space Complexity

O(n * 26^2)

Memoization table size plus recursion stack depth

⚡ Linearithmic Space

58.3K Views

Medium-High Frequency

~25 min Avg. Time

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

Dynamic Programming (Memoized Recursion) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler