Minimum Number of Steps to Make Two Strings Anagram II

Minimum Number of Steps to Make Two Strings Anagram II - Problem

Given two strings s and t, you need to find the minimum number of character additions to make them anagrams of each other.

In each step, you can append any character to either string s or string t. Your goal is to transform both strings so they contain exactly the same characters with the same frequencies.

What is an anagram? An anagram is a rearrangement of characters from one word to form another word using all characters exactly once. For example, "listen" and "silent" are anagrams.

Example: If s = "leetcode" and t = "coats", we need to add characters to make them anagrams. The optimal solution requires adding specific characters to balance the character frequencies between both strings.

Input & Output

example_1.py — Basic Example

$ Input: s = "leetcode", t = "coats"

› Output: 7

💡 Note: We need to add 'l', 'e', 'e', 't', 'd' to t and 'a', 's' to s to make them anagrams. Total additions = 5 + 2 = 7.

example_2.py — Already Anagrams

$ Input: s = "night", t = "thing"

› Output: 0

💡 Note: The strings are already anagrams of each other, so no additions are needed.

example_3.py — One Empty String

$ Input: s = "a", t = ""

› Output: 1

💡 Note: We need to add 'a' to string t to make both strings anagrams.

Constraints

1 ≤ s.length, t.length ≤ 5 × 10⁴
s and t consist of lowercase English letters only
Follow up: Can you solve this in O(1) space complexity?

Visualization

Tap to expand

Understanding the Visualization

Inventory Count

Count how many of each character we have in both strings

Calculate Imbalance

For each character, find the absolute difference between the two counts

Sum Total Deficit

Add up all the imbalances to get the total character deficit

Optimize Distribution

Since we can add to either string, we need half the total deficit

Key Takeaway

🎯 Key Insight: The minimum steps needed is half the sum of absolute character frequency differences, because we can strategically add characters to either string to balance them optimally.

Asked in

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

The optimal approach uses character frequency counting to solve this problem in O(n+m) time. By counting the frequency of each character in both strings and calculating the absolute differences, we can determine the minimum additions needed. The key insight is that the answer is the sum of absolute differences divided by 2, since each character addition reduces the total imbalance by 2.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Character Counting (Optimal)	O(n + m)	O(1)	Count character frequencies and calculate minimum additions needed in one pass
Brute Force (Generate All Combinations)	O(26^(m+n))	O(26^(m+n))	Try all possible character additions until strings become anagrams

Single Pass Character Counting (Optimal) — Algorithm Steps

Count character frequencies in both strings using hash maps
For each character, calculate the absolute difference in frequencies
Sum all the absolute differences
Return the sum divided by 2 (since we can add to either string)

Visualization

Tap to expand

Step-by-Step Walkthrough

Count frequencies

Create frequency maps for both strings

Find differences

Calculate |freq_s[char] - freq_t[char]| for each character

Sum differences

Add up all absolute differences

Return result

Divide by 2 since each addition reduces difference by 2

Code -

solution.c — C

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

#define MAX_LEN 1000

int minSteps(char* s, char* t) {
    int countS[26] = {0};
    int countT[26] = {0};
    
    // Count character frequencies
    int sLen = strlen(s);
    int tLen = strlen(t);
    
    for (int i = 0; i < sLen; i++) {
        countS[s[i] - 'a']++;
    }
    
    for (int i = 0; i < tLen; i++) {
        countT[t[i] - 'a']++;
    }
    
    int totalDiff = 0;
    
    // Calculate absolute differences
    for (int i = 0; i < 26; i++) {
        int diff = countS[i] - countT[i];
        if (diff < 0) diff = -diff;  // abs(diff)
        totalDiff += diff;
    }
    
    // Return half of total difference
    return totalDiff / 2;
}

int main() {
    char s[MAX_LEN], t[MAX_LEN];
    fgets(s, sizeof(s), stdin);
    fgets(t, sizeof(t), stdin);
    
    // Remove newlines and quotes
    s[strcspn(s, "\n")] = 0;
    t[strcspn(t, "\n")] = 0;
    
    if (s[0] == '"' && s[strlen(s)-1] == '"') {
        s[strlen(s)-1] = 0;
        memmove(s, s+1, strlen(s));
    }
    
    if (t[0] == '"' && t[strlen(t)-1] == '"') {
        t[strlen(t)-1] = 0;
        memmove(t, t+1, strlen(t));
    }
    
    printf("%d\n", minSteps(s, t));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Where n and m are lengths of strings s and t. We iterate through each string once

✓ Linear Growth

Space Complexity

O(1)

Only 26 possible characters (constant space for hash map)

✓ Linear Space

42.5K Views

Medium Frequency

~15 min Avg. Time

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

Single Pass Character Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler