Move Pieces to Obtain a String

Move Pieces to Obtain a String - Problem

You are given two strings start and target, both of length n. Each string consists only of the characters 'L', 'R', and '_' where:

Movement Rules:

The character 'L' represents a piece that can move to the left only if there is a blank space directly to its left
The character 'R' represents a piece that can move to the right only if there is a blank space directly to its right
The character '_' represents a blank space that can be occupied by any piece

Return true if it is possible to obtain the string target by moving the pieces of the string start any number of times. Otherwise, return false.

Input & Output

Example 1 — Valid Transformation

$ Input: start = "_L__R__R_", target = "L______RR"

› Output: true

💡 Note: L can move from position 1 to position 0. Both R pieces can move right: first R from position 4 to position 7, second R from position 7 to position 8.

Example 2 — Invalid Movement

$ Input: start = "R_L_", target = "__LR"

› Output: false

💡 Note: R cannot move left (from position 0 to position 3) and L cannot move right (from position 2 to position 2). The pieces cannot reach their target positions.

Example 3 — Different Piece Count

$ Input: start = "_R", target = "R_"

› Output: false

💡 Note: The R piece at position 1 cannot move left to position 0, as R pieces can only move right.

Constraints

n == start.length == target.length
1 ≤ n ≤ 10⁵
start and target consist of characters 'L', 'R', and '_'

Visualization

Tap to expand

Asked in

A Amazon 15 M Microsoft 12 G Google 8

The key insight is that pieces maintain their relative order and can only move in one direction. The optimal Two Pointers approach validates movement constraints in O(n) time by checking if each piece can reach its target position following the directional rules. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force Simulation

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

Try every possible sequence of piece movements by checking all adjacent swaps between pieces and blanks. Continue until either the target string is reached or no more valid moves can be made.

Two Pointers Validation

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

Skip blanks and compare pieces in order. Check if each L can move left and each R can move right to reach target position without violating movement constraints.

Brute Force Simulation — Algorithm Steps

Step 1: Generate all possible next states by swapping pieces with adjacent blanks
Step 2: Use BFS/DFS to explore all reachable configurations
Step 3: Check if target configuration is reachable

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with the given configuration

Generate Moves

Try all valid L-left and R-right movements

BFS Search

Continue until target found or no more moves

Code -

solution.c — C

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

#define MAX_QUEUE_SIZE 50000
#define MAX_VISITED_SIZE 50000

static char queue_states[MAX_QUEUE_SIZE][1001];
static char visited_states[MAX_VISITED_SIZE][1001];

typedef struct {
    int front;
    int rear;
    int size;
} Queue;

typedef struct {
    int count;
} VisitedSet;

void initQueue(Queue* q) {
    q->front = 0;
    q->rear = 0;
    q->size = 0;
}

bool pushQueue(Queue* q, char* state) {
    if (q->size >= MAX_QUEUE_SIZE) return false;
    strcpy(queue_states[q->rear], state);
    q->rear = (q->rear + 1) % MAX_QUEUE_SIZE;
    q->size++;
    return true;
}

void popQueue(Queue* q, char* state) {
    strcpy(state, queue_states[q->front]);
    q->front = (q->front + 1) % MAX_QUEUE_SIZE;
    q->size--;
}

bool isEmpty(Queue* q) {
    return q->size == 0;
}

void initVisited(VisitedSet* vs) {
    vs->count = 0;
}

bool contains(VisitedSet* vs, char* state) {
    for (int i = 0; i < vs->count; i++) {
        if (strcmp(visited_states[i], state) == 0) {
            return true;
        }
    }
    return false;
}

bool insertVisited(VisitedSet* vs, char* state) {
    if (vs->count >= MAX_VISITED_SIZE) return false;
    strcpy(visited_states[vs->count], state);
    vs->count++;
    return true;
}

int compare(const void* a, const void* b) {
    return *(char*)a - *(char*)b;
}

bool solution(char* start, char* target) {
    int len_start = strlen(start);
    int len_target = strlen(target);
    
    if (len_start != len_target) {
        return false;
    }
    
    // Check if same characters exist
    char s1[1001], s2[1001];
    strcpy(s1, start);
    strcpy(s2, target);
    qsort(s1, len_start, sizeof(char), compare);
    qsort(s2, len_target, sizeof(char), compare);
    if (strcmp(s1, s2) != 0) {
        return false;
    }
    
    if (strcmp(start, target) == 0) {
        return true;
    }
    
    VisitedSet visited;
    initVisited(&visited);
    Queue q;
    initQueue(&q);
    
    pushQueue(&q, start);
    insertVisited(&visited, start);
    
    while (!isEmpty(&q)) {
        char current[1001];
        popQueue(&q, current);
        
        if (strcmp(current, target) == 0) {
            return true;
        }
        
        int current_len = strlen(current);
        for (int i = 0; i < current_len - 1; i++) {
            // L can move left
            if (current[i] == '_' && current[i + 1] == 'L') {
                char newState[1001];
                strcpy(newState, current);
                char temp = newState[i];
                newState[i] = newState[i + 1];
                newState[i + 1] = temp;
                if (!contains(&visited, newState)) {
                    insertVisited(&visited, newState);
                    pushQueue(&q, newState);
                }
            }
            
            // R can move right
            if (current[i] == 'R' && current[i + 1] == '_') {
                char newState[1001];
                strcpy(newState, current);
                char temp = newState[i];
                newState[i] = newState[i + 1];
                newState[i + 1] = temp;
                if (!contains(&visited, newState)) {
                    insertVisited(&visited, newState);
                    pushQueue(&q, newState);
                }
            }
        }
    }
    
    return false;
}

int main() {
    char start[1001], target[1001];
    if (fgets(start, sizeof(start), stdin) == NULL) return 1;
    if (fgets(target, sizeof(target), stdin) == NULL) return 1;
    
    // Remove newlines
    start[strcspn(start, "\n")] = 0;
    target[strcspn(target, "\n")] = 0;
    
    bool result = solution(start, target);
    printf("%s\n", result ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each position can be in multiple states, leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(2^n)

Need to store all possible configurations in queue/visited set

⚠ Quadratic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

867 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler