Codestin Search App

Smallest String With Swaps - Problem

Array Hash Table String Depth-First Search Breadth-First Search Union Find Sorting Medium

Imagine you have a string of characters and a special set of swap rules that allow you to exchange characters at specific positions. Your goal is to create the lexicographically smallest string possible using these swaps.

Given a string s and an array of pairs pairs where pairs[i] = [a, b] indicates you can swap characters at indices a and b, you can perform these swaps any number of times. The key insight is that if you can swap A↔B and B↔C, then effectively you can rearrange A, B, and C in any order!

Goal: Return the lexicographically smallest string after optimally using all available swaps.

Example: With string "dcab" and pairs [[0,3],[1,2]], you can swap positions (0,3) and (1,2) to get "bacd" - the smallest possible arrangement.

Input & Output

example_1.py — Basic Case

$ Input: s = "dcab", pairs = [[0,3],[1,2]]

› Output: "bacd"

💡 Note: Indices 0 and 3 can swap (d↔b), indices 1 and 2 can swap (c↔a). We can rearrange to get 'bacd' which is lexicographically smallest.

example_2.py — Transitive Swaps

$ Input: s = "dcab", pairs = [[0,3],[1,2],[0,2]]

› Output: "abcd"

💡 Note: Now all indices are connected transitively: 0↔3, 1↔2, 0↔2 means 0,1,2,3 form one group. We can arrange all characters optimally to get 'abcd'.

example_3.py — No Swaps Possible

$ Input: s = "cba", pairs = []

› Output: "cba"

💡 Note: No pairs means no swaps possible, so the string remains unchanged.

Visualization

Tap to expand

Understanding the Visualization

Map Connections

Use Union-Find to build connected components from swap pairs

Group Characters

Collect all characters that belong to each connected component

Sort and Place

Sort characters within each group and place them back optimally

Key Takeaway

🎯 Key Insight: Use Union-Find to group indices that can swap transitively, then sort characters within each group for optimal lexicographic result.

Time & Space Complexity

Time Complexity

⏱️

O(n α(n) + m α(n))

Union-Find operations with path compression, where α is the inverse Ackermann function (practically constant)

✓ Linear Growth

Space Complexity

O(n)

Space for Union-Find structure and temporary character storage

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
0 ≤ pairs.length ≤ 10⁵
0 ≤ pairs[i][0], pairs[i][1] < s.length
pairs[i][0] ≠ pairs[i][1]
s contains only lowercase English letters

Asked in

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

The optimal solution uses Union-Find (Disjoint Set Union) to identify groups of indices that can be swapped transitively. Within each connected component, we sort the characters to get the lexicographically smallest arrangement. Time complexity: O(n α(n)) where α is the inverse Ackermann function.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find with Sorting (Optimal)	O(n α(n) + m α(n))	O(n)	Use Union-Find to group connected indices, then sort characters within each group

Union-Find with Sorting (Optimal) — Algorithm Steps

Build Union-Find structure from the pairs
Group all indices by their root parent
For each group, collect characters at those indices
Sort characters in each group
Place sorted characters back to their positions
Return the resulting string

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Union-Find

Connect indices that can be swapped

Group by Root

Collect all indices with same root parent

Sort Within Groups

Sort characters within each connected component

Code -

solution.c — C

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

typedef struct {
    int *parent;
    int *rank;
    int size;
} UnionFind;

UnionFind* createUF(int n) {
    UnionFind* uf = malloc(sizeof(UnionFind));
    uf->parent = malloc(n * sizeof(int));
    uf->rank = calloc(n, sizeof(int));
    uf->size = n;
    for (int i = 0; i < n; i++) uf->parent[i] = i;
    return uf;
}

int find(UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]);
    }
    return uf->parent[x];
}

void unionSets(UnionFind* uf, int x, int y) {
    int px = find(uf, x), py = find(uf, y);
    if (px == py) return;
    if (uf->rank[px] < uf->rank[py]) {
        uf->parent[px] = py;
    } else if (uf->rank[px] > uf->rank[py]) {
        uf->parent[py] = px;
    } else {
        uf->parent[py] = px;
        uf->rank[px]++;
    }
}

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

char* smallestStringWithSwaps(char* s, int pairs[][2], int pairsSize) {
    int n = strlen(s);
    UnionFind* uf = createUF(n);
    
    for (int i = 0; i < pairsSize; i++) {
        unionSets(uf, pairs[i][0], pairs[i][1]);
    }
    
    char* result = malloc((n + 1) * sizeof(char));
    strcpy(result, s);
    
    // Simple approach: for each root, collect and sort
    for (int root = 0; root < n; root++) {
        char chars[1000];
        int indices[1000];
        int count = 0;
        
        for (int i = 0; i < n; i++) {
            if (find(uf, i) == root && find(uf, root) == root) {
                chars[count] = s[i];
                indices[count] = i;
                count++;
            }
        }
        
        if (count > 1) {
            qsort(chars, count, sizeof(char), compare);
            for (int i = 0; i < count; i++) {
                result[indices[i]] = chars[i];
            }
        }
    }
    
    result[n] = '\0';
    return result;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n α(n) + m α(n))

Union-Find operations with path compression, where α is the inverse Ackermann function (practically constant)

✓ Linear Growth

Space Complexity

O(n)

Space for Union-Find structure and temporary character storage

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
0 ≤ pairs.length ≤ 10⁵
0 ≤ pairs[i][0], pairs[i][1] < s.length
pairs[i][0] ≠ pairs[i][1]
s contains only lowercase English letters

52.3K Views

Medium Frequency

~25 min Avg. Time

1.9K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Union-Find with Sorting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler