Rearrange String k Distance Apart

Rearrange String k Distance Apart - Problem

Hash Table String Greedy Sorting Heap (Priority Queue) Counting Hard

You're given a string s and an integer k. Your task is to rearrange the characters in the string such that no two identical characters are closer than k positions apart.

This is like organizing a seating arrangement where certain people need to be separated by at least k seats! If it's impossible to create such an arrangement, return an empty string "".

Key Challenge: You need to strategically place the most frequent characters first while ensuring they maintain the required distance.

Example: For string "aabbcc" with k=3, one valid arrangement could be "abcabc" - notice how each 'a' is 3 positions apart, same for 'b' and 'c'.

Input & Output

example_1.py — Basic case with k=3

$ Input: s = "aabbcc", k = 3

› Output: "abcabc"

💡 Note: Each character appears twice, and with k=3, we need at least 3 positions between same characters. The arrangement 'abcabc' satisfies this: 'a' appears at positions 0 and 3 (distance = 3), 'b' at 1 and 4 (distance = 3), 'c' at 2 and 5 (distance = 3).

example_2.py — Impossible case

$ Input: s = "aaadbbcc", k = 2

› Output: ""

💡 Note: Character 'a' appears 3 times, but with k=2 and string length 8, we can only place 'a' at most at positions 0, 2, 4, 6 - that's 4 possible positions for 3 occurrences. However, the arrangement is still impossible due to the distribution of other characters.

example_3.py — Edge case k=0

$ Input: s = "aaab", k = 0

› Output: "aaab"

💡 Note: When k=0 or k=1, no rearrangement constraints apply, so we can return the original string or any permutation. The original string itself is valid.

Constraints

1 ≤ s.length ≤ 10⁵
0 ≤ k ≤ s.length
s consists of lowercase English letters only
If multiple valid arrangements exist, return any one of them

Visualization

Tap to expand

Asked in

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

The optimal solution uses a greedy approach with priority queue to always place the most frequent character first, combined with a cooldown mechanism to track when each character can be used again. This ensures maximum utilization while respecting the k-distance constraint, achieving O(n log k) time complexity.

Common Approaches

✓ Brute Force (Generate All Permutations)

⏱️ Time: O(n! × n) Space: O(n)

Generate every possible permutation of the input string and check if any arrangement satisfies the k-distance constraint. This approach is extremely inefficient but conceptually straightforward.

Greedy + Priority Queue (Optimal)

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

This optimal approach uses a greedy strategy with a max-heap (priority queue) to always place the most frequent remaining character. A cooldown mechanism ensures no character is placed too soon after its last occurrence.

Brute Force (Generate All Permutations) — Algorithm Steps

Generate all permutations of the input string
For each permutation, check if any two identical characters are within k distance
Return the first valid permutation found
If no valid permutation exists, return empty string

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutation

Create next permutation of characters

Validate Distance

Check if k-distance constraint is satisfied

Continue or Return

Return if valid, otherwise try next permutation

Code -

solution.c — C

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

#define MAX_CHARS 26
#define MAX_LEN 100005

typedef struct {
    char ch;
    int freq;
    int nextAvailable;
} CharInfo;

int compare(const void *a, const void *b) {
    CharInfo *ca = (CharInfo*)a;
    CharInfo *cb = (CharInfo*)b;
    return cb->freq - ca->freq;
}

char* rearrangeString(char* s, int k) {
    int n = strlen(s);
    if (k <= 1) {
        char* result = malloc((n + 1) * sizeof(char));
        strcpy(result, s);
        return result;
    }
    
    if (n == 0) {
        char* result = malloc(1 * sizeof(char));
        result[0] = '\0';
        return result;
    }
    
    // Count character frequencies
    int freq[MAX_CHARS] = {0};
    for (int i = 0; i < n; i++) {
        freq[s[i] - 'a']++;
    }
    
    // Find max frequency and check feasibility
    int maxFreq = 0;
    for (int i = 0; i < MAX_CHARS; i++) {
        if (freq[i] > maxFreq) {
            maxFreq = freq[i];
        }
    }
    
    if ((maxFreq - 1) * k + 1 > n) {
        char* result = malloc(1 * sizeof(char));
        result[0] = '\0';
        return result;
    }
    
    // Create array of character info
    static CharInfo chars[MAX_CHARS];
    int charCount = 0;
    for (int i = 0; i < MAX_CHARS; i++) {
        if (freq[i] > 0) {
            chars[charCount].ch = 'a' + i;
            chars[charCount].freq = freq[i];
            chars[charCount].nextAvailable = 0;
            charCount++;
        }
    }
    
    qsort(chars, charCount, sizeof(CharInfo), compare);
    
    char* result = malloc((n + 1) * sizeof(char));
    int resultLen = 0;
    static CharInfo waitQueue[MAX_LEN];
    int waitQueueSize = 0;
    int heapSize = charCount;
    
    while (heapSize > 0 || waitQueueSize > 0) {
        // Add back characters that have waited long enough
        int newWaitSize = 0;
        for (int i = 0; i < waitQueueSize; i++) {
            if (waitQueue[i].nextAvailable <= resultLen) {
                if (waitQueue[i].freq > 0) {
                    chars[heapSize] = waitQueue[i];
                    heapSize++;
                    qsort(chars, heapSize, sizeof(CharInfo), compare);
                }
            } else {
                waitQueue[newWaitSize++] = waitQueue[i];
            }
        }
        waitQueueSize = newWaitSize;
        
        if (heapSize == 0) {
            result[0] = '\0';
            return result;
        }
        
        // Take the most frequent available character
        CharInfo current = chars[0];
        heapSize--;
        for (int i = 0; i < heapSize; i++) {
            chars[i] = chars[i + 1];
        }
        
        result[resultLen++] = current.ch;
        
        // If this character still has remaining count, add to wait queue
        if (current.freq > 1) {
            waitQueue[waitQueueSize].ch = current.ch;
            waitQueue[waitQueueSize].freq = current.freq - 1;
            waitQueue[waitQueueSize].nextAvailable = resultLen + k - 1;
            waitQueueSize++;
        }
    }
    
    result[resultLen] = '\0';
    return result;
}

int main() {
    static char line[MAX_LEN];
    
    if (fgets(line, sizeof(line), stdin)) {
        line[strcspn(line, "\n")] = 0;
        
        int k;
        if (scanf("%d", &k) == 1) {
            char* result = rearrangeString(line, k);
            printf("%s\n", result);
            free(result);
        } else {
            printf("\n");
        }
    } else {
        printf("\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

O(n!) to generate all permutations, O(n) to validate each permutation

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation and recursion stack

⚡ Linearithmic Space

31.7K Views

Medium-High Frequency

~25 min Avg. Time

1.3K 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 (Generate All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler