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).
We use a hash table last to record the last occurrence position of each character. We iterate over each character in the string. If the current character has appeared before and the difference between the current index and its last occurrence index is at most k, we skip the character; otherwise, we add the character to the answer and update its position in the hash table.
The time complexity is O(n), and the space complexity is O(|\Sigma|), where n is the length of the string, and |\Sigma| is the size of the character set. In this problem, the character set consists of lowercase English letters, so |\Sigma| is a constant.
Python
Java
C++
Go
TypeScript
| 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 |
LeetCode 3853 | Merge Close Characters | Simulation | Java • Code Kage • 167 views views
Watch 3 more video solutions →Practice Merge Close Characters with our built-in code editor and test cases.
Practice on FleetCodePractice this problem
Open in Editor