Two Strings Close LeetCode 1657 Guide

LeetCode 1657 asks you to determine whether two strings word1 and word2 are "close." Two strings are close if you can transform one into the other using any number of the two allowed operations.

Operation 1 lets you swap any two characters in the string. You can swap any pair, not just adjacent ones, and you can do this as many times as you want. This means you can rearrange the string into any permutation freely.

Operation 2 lets you transform every occurrence of one character into another character and simultaneously transform every occurrence of that second character into the first. For example, transforming all "a"s to "b"s and all "b"s to "a"s at the same time. The goal is to determine if word1 can become word2 using any combination of these operations.

The two operations together have a precise mathematical effect. Operation 1 (swap) gives you full control over character order — you can rearrange the string into any permutation. This means the positions of characters are irrelevant; only the frequency of each character matters.

Operation 2 (transform) lets you reassign which frequency belongs to which character. If word1 has "a" appearing 3 times and "b" appearing 2 times, you can use operation 2 to make "a" appear 2 times and "b" appear 3 times. You are shuffling the frequency values among the character slots.

This leads to two necessary and sufficient conditions: both strings must use exactly the same set of distinct characters, and the multiset of frequency values (sorted) must be identical. If either condition fails, no sequence of operations can bridge the gap.

Operation 2 can swap the frequencies between two characters, but it cannot introduce a character that does not already exist in the string. If word1 contains the character "z" but word2 does not, no sequence of swaps or transforms will ever produce a string without "z" from word1.

Similarly, operation 1 only rearranges existing characters — it cannot create or destroy characters. So the set of distinct characters present in both strings must be exactly equal for the strings to be close.

This check is straightforward: compute the set of unique characters in word1 and the set in word2, then verify they are equal. If word1 has any character that word2 lacks, or vice versa, the answer is immediately false.

Once you confirm the character sets match, the question becomes: can you assign the frequencies of word1 to the characters so they match word2? Operation 2 lets you swap the frequencies of any two existing characters. By chaining multiple applications of operation 2, you can permute the frequency assignments arbitrarily among the characters.

This means you can assign any frequency value to any character — as long as the bag (multiset) of frequency values is the same in both strings. If word1 has frequencies {a:3, b:2, c:1} and word2 has {a:1, b:3, c:2}, sorted both give [1, 2, 3] and they match.

If the sorted frequency lists differ, no amount of operation 2 applications can fix it — you cannot change the total count of any character, only redistribute which character holds which count. So the sorted multiset of frequency values must be identical.

Consider word1 = "aacabb" and word2 = "bbcbaa". For word1, count the characters: a appears 3 times, b appears 2 times, c appears 1 time — so freq1 = {a:3, b:2, c:1}. For word2: b appears 3 times, a appears 2 times, c appears 1 time — so freq2 = {b:3, a:2, c:1}.

Check condition 1: set of unique characters in word1 = {a, b, c}; set in word2 = {a, b, c}. They are equal, so the first condition passes. Now sort the frequency values: sorted(freq1.values()) = [1, 2, 3] and sorted(freq2.values()) = [1, 2, 3]. They match, so the second condition passes.

The answer is true. Intuitively, apply operation 2 to swap a and b in word1: now a appears 2 times and b appears 3 times, matching word2's frequency profile. Then use operation 1 to rearrange into "bbcbaa". Both operations together complete the transformation.

In Python, use Counter from collections to build frequency maps in O(n). Check set equality with set(counter1.keys()) == set(counter2.keys()). Then sort the values and compare: sorted(counter1.values()) == sorted(counter2.values()). The sort is O(26 log 26) since there are at most 26 distinct lowercase letters — effectively O(1). Overall time is O(n) and space is O(1) since the alphabet is bounded.

In Java, use a HashMap<Character, Integer> or an int array of size 26 for the frequency maps. Convert the frequency maps to arrays, sort them, and compare with Arrays.equals(). Check the character sets by verifying that every position in the int array is either both zero or both non-zero. The logic mirrors Python exactly.

A common optimization: first check if word1.length() != word2.length() and return false immediately — if they have different lengths, no rearrangement of characters can make them equal, so they cannot be close. This early exit avoids building frequency maps in the trivially false case.

LeetCode 1657 belongs to the frequency-comparison family of string problems. The most direct relative is Valid Anagram (LeetCode 242), where you check if two strings have exactly the same character frequencies — a stricter version of the close condition that requires identical frequency maps, not just identical multisets.

Group Anagrams (LeetCode 49) extends the idea: you group strings by their sorted frequency signature (or sorted character string), exactly the technique used here. Ransom Note (LeetCode 383) checks whether one string's frequencies are a subset of another's — another variation on the frequency comparison theme.

For deeper practice, try Custom Sort String (LeetCode 791) and Sort Characters By Frequency (LeetCode 451), both of which require building frequency maps and manipulating the resulting sorted structure. Mastering frequency counting patterns unlocks a large class of string and array problems.