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

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

example_2.py — Single character

$ Input: word = "HAPPY"

› Output: 6

💡 Note: Start both fingers free. Place finger1 at 'H' (cost=0), move to 'A' (cost=3), place finger2 at 'P' (cost=0), move to another 'P' (cost=0), move finger1 to 'Y' (cost=3). Total: 0+3+0+0+3=6

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

Understanding the Visualization

Setup Grid

Letters A-Z arranged in 6×5 grid, A at (0,0), Z at (4,1)

Initialize

Both fingers start free - can be placed anywhere at no cost

Choose Finger

For each letter, decide which finger to move based on minimum distance

Calculate Distance

Use Manhattan distance formula: |x1-x2| + |y1-y2|

Key Takeaway

🎯 Key Insight: Use dynamic programming to track optimal finger positions, taking advantage of free initial placement and making locally optimal decisions at each step.

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

Approach	Time	Space	Notes
✓ Dynamic Programming (Memoized Recursion)	O(n * 26^2)	O(n * 26^2)	Use memoization to avoid recalculating the same subproblems

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;

MemoItem memo[MAXMEMO];
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) {
    if (idx == strlen(word)) 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() {
    char word[1000];
    fgets(word, sizeof(word), stdin);
    char* start = strchr(word, '"') + 1;
    char* end = strrchr(word, '"');
    *end = '\0';
    printf("%d\n", solve(start, 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.2K 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