Furthest Point From Origin

Furthest Point From Origin - Problem

String Counting Easy

You are given a string moves of length n consisting only of characters 'L', 'R', and '_'. The string represents your movement on a number line starting from the origin 0.

In the ith move, you can choose one of the following directions:

move to the left if moves[i] = 'L' or moves[i] = '_'
move to the right if moves[i] = 'R' or moves[i] = '_'

Return the distance from the origin of the furthest point you can get to after n moves.

Input & Output

Example 1 — Basic Case

$ Input: moves = "L_RL__R"

› Output: 3

💡 Note: We have L=2, R=2, _=3. Net from fixed moves: 2-2=0. Since net is 0, we can add all flexible moves in either direction to get maximum distance: 0+3=3.

Example 2 — All Flexible

$ Input: moves = "___"

› Output: 3

💡 Note: All moves are flexible. Assign all to same direction (e.g., all R) gives distance 3.

Example 3 — No Flexible Moves

$ Input: moves = "LLR"

› Output: 1

💡 Note: No flexible moves. Final position: -1-1+1=-1, distance is 1.

Constraints

1 ≤ moves.length ≤ 2000
moves[i] is either 'L', 'R', or '_'

Visualization

Tap to expand

Asked in

G Google 15 M Meta 12 a Amazon 8

The key insight is that all flexible moves ('_') should be assigned to the same direction to maximize distance from origin. The optimal approach counts L, R, and _ characters, calculates the net position from fixed moves, then adds all flexible moves in the direction that maximizes the absolute distance. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Combinations

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

For each '_' character, try both 'L' and 'R' options recursively. Calculate the final position for each combination and return the maximum absolute distance from origin.

Greedy - Count and Maximize

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

Count the number of 'L', 'R', and '_' characters. To maximize distance, assign all '_' characters to the direction that creates the largest absolute difference from origin.

Brute Force - Try All Combinations — Algorithm Steps

Recursively try L and R for each '_' character
Calculate final position for each combination
Return maximum absolute distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at position 0

Branch

For each '_', try both L and R

Maximum

Return the furthest distance found

Code -

solution.c — C

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

int dfs(char* moves, int index, int position, int len) {
    if (index == len) {
        return abs(position);
    }
    
    if (moves[index] == 'L') {
        return dfs(moves, index + 1, position - 1, len);
    } else if (moves[index] == 'R') {
        return dfs(moves, index + 1, position + 1, len);
    } else { // '_'
        int leftResult = dfs(moves, index + 1, position - 1, len);
        int rightResult = dfs(moves, index + 1, position + 1, len);
        return leftResult > rightResult ? leftResult : rightResult;
    }
}

int solution(char* moves) {
    return dfs(moves, 0, 0, strlen(moves));
}

int main() {
    char moves[1001];
    fgets(moves, sizeof(moves), stdin);
    moves[strcspn(moves, "\n")] = 0;
    int result = solution(moves);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^k)

k is the number of '_' characters, each has 2 choices

✓ Linear Growth

Space Complexity

O(k)

Recursion depth equals number of '_' characters

✓ Linear Space

25.0K Views

Medium Frequency

~10 min Avg. Time

850 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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler