Make Number of Distinct Characters Equal

Make Number of Distinct Characters Equal - Problem

You are given two 0-indexed strings word1 and word2.

A move consists of choosing two indices i and j such that 0 <= i < word1.length and 0 <= j < word2.length and swapping word1[i] with word2[j].

Return true if it is possible to get the number of distinct characters in word1 and word2 to be equal with exactly one move. Return false otherwise.

Input & Output

Example 1 — Basic Case

$ Input: word1 = "ac", word2 = "b"

› Output: false

💡 Note: word1 = "ac" has 2 distinct characters {a,c}, word2 = "b" has 1 distinct character {b}. Swapping 'a' with 'b' gives word1 = "bc" (2 distinct) and word2 = "a" (1 distinct). Swapping 'c' with 'b' gives word1 = "ab" (2 distinct) and word2 = "c" (1 distinct). No single swap can make both words have equal distinct character counts.

Example 2 — Already Equal

$ Input: word1 = "ab", word2 = "cd"

› Output: false

💡 Note: word1 has 2 distinct characters, word2 has 2 distinct characters. They're already equal, but we need exactly one swap. Any single swap will change the counts, so it's impossible to maintain equality with exactly one move.

Example 3 — Large Difference

$ Input: word1 = "abcc", word2 = "aab"

› Output: true

💡 Note: word1 has 3 distinct characters {a,b,c}, word2 has 2 distinct characters {a,b}. We can swap one 'c' from word1 with 'a' from word2, making both have the same distinct count.

Constraints

1 ≤ word1.length, word2.length ≤ 100
word1 and word2 consist of lowercase English letters.

Visualization

Tap to expand

Asked in

M Meta 8 a Amazon 5

The key insight is to calculate how distinct character counts change when swapping characters, without actually reconstructing strings. The frequency count approach is most efficient: Time O(n×m), Space O(1).

Common Approaches

✓ Binary Search Answer

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

Brute Force - Try All Swaps

⏱️ Time: O(n×m×(n+m)) Space: O(1)

For each character in word1 and each character in word2, simulate the swap and count distinct characters in both resulting strings. Return true if any swap makes the counts equal.

Frequency Count Optimization

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

Count character frequencies in both strings first. Then for each possible swap, calculate how the distinct counts would change without actually performing string operations.

Set-Based Optimization

⏱️ Time: O(d₁×d₂) Space: O(d₁+d₂)

Instead of checking every character occurrence, iterate through unique characters only. Use sets to track distinct characters and calculate changes more efficiently.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* ia = (int*)a;
    int* ib = (int*)b;
    return ia[0] - ib[0];
}

int canAchieveScore(int intervals[][3], int n, int score) {
    int* chosen = (int*)malloc(n * sizeof(int));
    chosen[intervals[0][2]] = intervals[0][0];
    
    for (int i = 1; i < n; i++) {
        int intervalStart = intervals[i][0];
        int intervalEnd = intervals[i][1];
        int originalIdx = intervals[i][2];
        
        int minAllowed = intervalStart;
        // Must be at least 'score' away from ALL previously chosen values
        for (int j = 0; j < i; j++) {
            int prevVal = chosen[intervals[j][2]];
            if (prevVal + score > minAllowed) {
                minAllowed = prevVal + score;
            }
        }
        
        if (minAllowed > intervalEnd) {
            free(chosen);
            return 0;
        }
        
        chosen[originalIdx] = minAllowed;
    }
    
    free(chosen);
    return 1;
}

int solution(int* start, int n, int d) {
    if (n == 1) return 0;
    
    // Sort intervals by start position for greedy placement
    int intervals[1000][3];
    int maxStart = start[0];
    for (int i = 0; i < n; i++) {
        intervals[i][0] = start[i];
        intervals[i][1] = start[i] + d;
        intervals[i][2] = i;
        if (start[i] > maxStart) maxStart = start[i];
    }
    
    qsort(intervals, n, sizeof(intervals[0]), compare);
    
    // Binary search on answer
    int left = 0, right = maxStart + d;
    int result = 0;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canAchieveScore(intervals, n, mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int start[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] >= '0' && token[0] <= '9') {
            start[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int d;
    scanf("%d", &d);
    
    printf("%d\n", solution(start, n, d));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.5K Views

Medium Frequency

~25 min Avg. Time

234 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