<p>You are given a string <code>s</code> and an integer <code>repeatLimit</code>. Construct a new string <code>repeatLimitedString</code> using the characters of <code>s</code> such that no letter appears <strong>more than</strong> <code>repeatLimit</code> times <strong>in a row</strong>. You do <strong>not</strong> have to use all characters from <code>s</code>.</p>

<p>Return <em>the <strong>lexicographically largest</strong> </em><code>repeatLimitedString</code> <em>possible</em>.</p>

<p>A string <code>a</code> is <strong>lexicographically larger</strong> than a string <code>b</code> if in the first position where <code>a</code> and <code>b</code> differ, string <code>a</code> has a letter that appears later in the alphabet than the corresponding letter in <code>b</code>. If the first <code>min(a.length, b.length)</code> characters do not differ, then the longer string is the lexicographically larger one.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> s = &quot;cczazcc&quot;, repeatLimit = 3
<strong>Output:</strong> &quot;zzcccac&quot;
<strong>Explanation:</strong> We use all of the characters from s to construct the repeatLimitedString &quot;zzcccac&quot;.
The letter &#39;a&#39; appears at most 1 time in a row.
The letter &#39;c&#39; appears at most 3 times in a row.
The letter &#39;z&#39; appears at most 2 times in a row.
Hence, no letter appears more than repeatLimit times in a row and the string is a valid repeatLimitedString.
The string is the lexicographically largest repeatLimitedString possible so we return &quot;zzcccac&quot;.
Note that the string &quot;zzcccca&quot; is lexicographically larger but the letter &#39;c&#39; appears more than 3 times in a row, so it is not a valid repeatLimitedString.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> s = &quot;aababab&quot;, repeatLimit = 2
<strong>Output:</strong> &quot;bbabaa&quot;
<strong>Explanation:</strong> We use only some of the characters from s to construct the repeatLimitedString &quot;bbabaa&quot;. 
The letter &#39;a&#39; appears at most 2 times in a row.
The letter &#39;b&#39; appears at most 2 times in a row.
Hence, no letter appears more than repeatLimit times in a row and the string is a valid repeatLimitedString.
The string is the lexicographically largest repeatLimitedString possible so we return &quot;bbabaa&quot;.
Note that the string &quot;bbabaaa&quot; is lexicographically larger but the letter &#39;a&#39; appears more than 2 times in a row, so it is not a valid repeatLimitedString.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= repeatLimit &lt;= s.length &lt;= 10<sup>5</sup></code></li>
	<li><code>s</code> consists of lowercase English letters.</li>
</ul>

import heapq
from collections import Counter

class Solution:
    def repeatLimitedString(self, s: str, repeatLimit: int) -> str:
        # Step 1: Count the frequency of each character
        char_count = Counter(s)
        
        # Step 2: Create a priority queue (max heap) with characters and their frequencies
        # Characters are stored as negative values to simulate a max heap
        pq = [(-ord(ch), freq) for ch, freq in char_count.items()]
        heapq.heapify(pq)
        
        result = []
        
        # Function to add characters to the result and update the priority queue
        def add_chars(ch, freq):
            count = min(freq, repeatLimit)
            result.append(ch * count)
            freq -= count
            return freq
        
        # Step 3: Construct the result string
        while pq:
            ch1, freq1 = heapq.heappop(pq)
            ch1 = chr(-ch1)
            
            # Add characters to the result
            freq1 = add_chars(ch1, freq1)
            
            # If there are remaining characters of ch1, push them back to the priority queue
            if freq1 > 0:
                # If there are no more characters available, break
                if not pq:
                    break
                
                # Use the next largest character temporarily
                ch2, freq2 = heapq.heappop(pq)
                ch2 = chr(-ch2)
                
                # Add one occurrence of the next largest character
                result.append(ch2)
                freq2 -= 1
                
                # Push the remaining characters back to the priority queue
                if freq2 > 0:
                    heapq.heappush(pq, (-ord(ch2), freq2))
                
                # Push the remaining characters of ch1 back to the priority queue
                if freq1 > 0:
                    heapq.heappush(pq, (-ord(ch1), freq1))
        
        return ''.join(result)

# Example usage:
solution = Solution()
s = "cczazcc"
repeatLimit = 3
print(solution.repeatLimitedString(s, repeatLimit))  # Output: "zzcccac"

s = "aababab"
repeatLimit = 2
print(solution.repeatLimitedString(s, repeatLimit))  # Output: "bbabaa"
260