Freedom Trail

Freedom Trail - Problem

In the video game Fallout 4, the quest "Road to Freedom" requires players to reach a metal dial called the "Freedom Trail Ring" and use the dial to spell a specific keyword to open the door.

Given a string ring that represents the code engraved on the outer ring and another string key that represents the keyword that needs to be spelled, return the minimum number of steps to spell all the characters in the keyword.

Initially, the first character of the ring is aligned at the "12:00" direction. You should spell all the characters in key one by one by rotating the ring clockwise or anticlockwise to make each character of the string key aligned at the "12:00" direction and then by pressing the center button.

At the stage of rotating the ring to spell the key character key[i]:

You can rotate the ring clockwise or anticlockwise by one place, which counts as one step.
The final purpose of the rotation is to align one of ring's characters at the "12:00" direction, where this character must equal key[i].
If the character key[i] has been aligned at the "12:00" direction, press the center button to spell, which also counts as one step.
After the pressing, you could begin to spell the next character in the key (next stage). Otherwise, you have finished all the spelling.

Input & Output

Example 1 — Basic Case

$ Input: ring = "godding", key = "gd"

› Output: 4

💡 Note: Start at 'g'(0), press button (1 step). Rotate to 'd'(2): min(2 clockwise, 5 anticlockwise) = 2 steps. Press button (1 step). Total: 1 + 2 + 1 = 4 steps.

Example 2 — Single Character

$ Input: ring = "godding", key = "g"

› Output: 1

💡 Note: Already at 'g'(0), just press button. Total: 1 step.

Example 3 — Multiple Choices

$ Input: ring = "abcde", key = "ae"

› Output: 3

💡 Note: Start at 'a'(0), press button (1 step). Rotate to 'e'(4): min(4 clockwise, 1 anticlockwise) = 1 step. Press button (1 step). Total: 1 + 1 + 1 = 3 steps.

Constraints

1 ≤ ring.length, key.length ≤ 100
ring and key consist of only lower case English letters
It's guaranteed that all characters in key exist in ring

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8 f Facebook 6

The key insight is that each character in the key can appear at multiple positions in the ring, and we must choose the position that minimizes total rotation steps. The optimal approach uses Dynamic Programming with a 2D table where dp[i][j] represents minimum steps to spell first i characters ending at ring position j. Time: O(n×m²), Space: O(n×m).

Common Approaches

✓ Optimized

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

Brute Force DFS

⏱️ Time: O(k^n) Space: O(n)

For each character in the key, find all positions where it appears in the ring and recursively calculate the minimum steps by trying each position.

Dynamic Programming

⏱️ Time: O(n * m²) Space: O(n * m)

Use 2D DP where dp[i][j] represents minimum steps to spell first i characters of key ending at position j in ring. Build the solution iteratively from smaller subproblems.

Memoized DFS

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

Same as brute force but cache the results of subproblems to avoid recalculating the minimum steps for the same (ring_position, key_position) state.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int findRotateSteps(char* ring, char* key) {
    int m = strlen(ring);
    int n = strlen(key);
    
    // positions[c] stores all positions where character c appears in ring
    int positions[26][100];  // assuming max 100 positions per character
    int pos_counts[26] = {0};
    
    // Build position map
    for (int i = 0; i < m; i++) {
        int c = ring[i] - 'a';
        positions[c][pos_counts[c]++] = i;
    }
    
    // dp[i][j] = minimum steps to spell first i characters of key, ending at position j
    int dp[101][101];
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j < m; j++) {
            dp[i][j] = 1000000;  // large number as infinity
        }
    }
    
    // Base case: we can start at any position of the first character for free
    int first_char = key[0] - 'a';
    for (int i = 0; i < pos_counts[first_char]; i++) {
        int pos = positions[first_char][i];
        int steps = min(pos, m - pos) + 1;  // rotation steps + press
        dp[1][pos] = steps;
    }
    
    // Fill dp table
    for (int i = 1; i < n; i++) {
        int curr_char = key[i] - 'a';
        
        for (int prev_pos = 0; prev_pos < m; prev_pos++) {
            if (dp[i][prev_pos] == 1000000) continue;
            
            // Try all positions of current character
            for (int j = 0; j < pos_counts[curr_char]; j++) {
                int curr_pos = positions[curr_char][j];
                
                // Calculate rotation steps
                int clockwise = (curr_pos - prev_pos + m) % m;
                int counterclockwise = (prev_pos - curr_pos + m) % m;
                int rotation_steps = min(clockwise, counterclockwise);
                
                // Total steps = previous steps + rotation + press
                int total_steps = dp[i][prev_pos] + rotation_steps + 1;
                dp[i + 1][curr_pos] = min(dp[i + 1][curr_pos], total_steps);
            }
        }
    }
    
    // Find minimum among all ending positions
    int result = 1000000;
    for (int j = 0; j < m; j++) {
        result = min(result, dp[n][j]);
    }
    
    return result;
}

int main() {
    char ring[101];
    char key[101];
    
    fgets(ring, sizeof(ring), stdin);
    fgets(key, sizeof(key), stdin);
    
    // Remove newlines
    ring[strcspn(ring, "\n")] = 0;
    key[strcspn(key, "\n")] = 0;
    
    printf("%d\n", findRotateSteps(ring, key));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.0K Views

Medium Frequency

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