Watch 4 video solutions for Merge Close Characters, a medium level problem involving Hash Table, String. This walkthrough by Code Kage has 167 views views. Want to try solving it yourself? Practice on FleetCode or read the detailed text solution.
You are given a string s consisting of lowercase English letters and an integer k.
Two equal characters in the current string s are considered close if the distance between their indices is at most k.
When two characters are close, the right one merges into the left. Merges happen one at a time, and after each merge, the string updates until no more merges are possible.
Return the resulting string after performing all possible merges.
Note: If multiple merges are possible, always merge the pair with the smallest left index. If multiple pairs share the smallest left index, choose the pair with the smallest right index.
Example 1:
Input: s = "abca", k = 3
Output: "abc"
Explanation:
'a' at indices i = 0 and i = 3 are close as 3 - 0 = 3 <= k.'a' and s = "abc".Example 2:
Input: s = "aabca", k = 2
Output: "abca"
Explanation:
'a' at indices i = 0 and i = 1 are close as 1 - 0 = 1 <= k.'a' and s = "abca".'a' characters at indices i = 0 and i = 3 are not close as k < 3, so no further merges occur.Example 3:
Input: s = "yybyzybz", k = 2
Output: "ybzybz"
Explanation:
'y' at indices i = 0 and i = 1 are close as 1 - 0 = 1 <= k.'y' and s = "ybyzybz".'y' at indices i = 0 and i = 2 are close as 2 - 0 = 2 <= k.'y' and s = "ybzybz".
Constraints:
1 <= s.length <= 1001 <= k <= s.lengths consists of lowercase English letters.Problem Overview: You are given a string and must merge characters that are considered close (typically adjacent in alphabet order). Characters that differ by at most one position can be grouped together, and the final result depends on combining their frequencies efficiently.
Approach 1: Sorting + Linear Merge (O(n log n) time, O(n) space)
One straightforward strategy is to sort the characters in the string and then scan from left to right. After sorting, characters that are alphabetically close appear next to each other. You iterate through the sorted sequence and merge characters when their ASCII difference is ≤ 1. A running group tracks the current merged characters. Sorting dominates the complexity, giving O(n log n) time and O(n) auxiliary space for the sorted array.
Approach 2: Hash Table Frequency Merge (O(n) time, O(1) space)
The optimal solution counts character frequencies using a hash table. You iterate through the string once and store the frequency of each character. Since lowercase letters come from a fixed alphabet, you then iterate through the possible characters and merge counts of neighbors such as c with c-1 or c+1 if they are considered close. This avoids sorting and relies on constant-time hash lookups. The algorithm processes the string once and scans the alphabet once, giving O(n) time and O(1) space because the alphabet size is fixed.
This approach works well because the problem is fundamentally about frequency aggregation rather than positional ordering. Using a hash map lets you count characters quickly and then reason about adjacency directly in the alphabet rather than in the string itself.
Implementation usually uses a frequency array of size 26 (for lowercase letters) or a dictionary if the character range is larger. Each character contributes a constant-time increment, and merging operations are simple arithmetic on neighboring buckets. The technique is common in string problems where relationships between characters depend on their values rather than positions.
Recommended for interviews: The hash table approach is what interviewers expect. A sorting-based solution demonstrates the basic idea but costs O(n log n). Using a hash map or fixed-size frequency array shows you recognize that the alphabet is bounded and can reduce the complexity to O(n).
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Sorting + Linear Merge | O(n log n) | O(n) | When simplicity matters and sorting the characters is acceptable |
| Hash Table Frequency Merge | O(n) | O(1) | General optimal solution using frequency counting and constant-time lookups |