Smallest K-Length Subsequence With Occurrences of a Letter solution and explanation

def smallestSubsequence(s: str, k: int, letter: str, repetition: int) -> str:
    stack = []
    letter_count = s.count(letter)
    for i, char in enumerate(s):
        while (stack and
               (len(stack) + len(s) - i > k) and
               (stack[-1] > char) and
               (stack[-1] != letter or letter_count > repetition)):
            if stack[-1] == letter:
                repetition += 1
            stack.pop()

        if len(stack) < k:
            if char == letter or k - len(stack) > repetition:
                if char == letter:
                    repetition -= 1
                stack.append(char)

        if char == letter:
            letter_count -= 1
    return ''.join(stack)

function smallestSubsequence(s, k, letter, repetition) {
    let stack = [];
    let letterCount = (s.split(letter).length - 1);
    let remain = s.length;
    for (let i = 0; i < s.length; i++) {
        let char = s[i];
        while (stack.length &&
               stack.length + remain - i > k &&
               stack[stack.length - 1] > char &&
               (stack[stack.length - 1] != letter || letterCount > repetition)) {
            if (stack.pop() == letter) repetition++;
        }
        if (stack.length < k) {
            if (char == letter || k - stack.length > repetition) {
                if (char == letter) repetition--;
                stack.push(char);
            }
        }
        if (char == letter) letterCount--;
    }
    return stack.join('');
}

import java.util.PriorityQueue;

public String smallestSubsequence(String s, int k, char letter, int repetition) {
    int[] letter_count = new int[s.length()];
    int lc = 0;
    for (int i = s.length() - 1; i >= 0; --i) {
        if (s.charAt(i) == letter) {
            lc++;
        }
        letter_count[i] = lc;
    }
    StringBuilder result = new StringBuilder();
    PriorityQueue<Character> pq = new PriorityQueue<>();
    int total_letter_count = 0;
    for (int i = 0; i < s.length(); ++i) {
        while (!pq.isEmpty() && result.length() + pq.size() - 1 + letter_count[i] >= k) {
            char top = pq.poll();
            result.append(top);
            total_letter_count += (top == letter ? 1 : 0);
        }
        if (result.length() < k) {
            pq.offer(s.charAt(i));
        }
    }
    return result.toString();
}

#include <vector>
#include <queue>
#include <string>
using namespace std;

string smallestSubsequence(string s, int k, char letter, int repetition) {
    vector<int> letter_count(s.size(), 0);
    int lc = 0;
    for (int i = s.size() - 1; i >= 0; --i) {
        lc += (s[i] == letter);
        letter_count[i] = lc;
    }
    string result;
    priority_queue<char, vector<char>, greater<char>> pq;
    int total_letter_count = 0, l_count = 0, start = 0;
    for (int i = 0; i < s.size(); ++i) {
        while (!pq.empty() && result.size() + pq.size() - 1 + letter_count[i] >= k) {
            result += pq.top();
            pq.pop();
            total_letter_count += (result.back() == letter);
        }
        if (result.size() < k) {
            pq.push(s[i]);
        }
    }
    return result;
}