2026-05-25：删除重复字符后的字典序最小字符串。用go语言，给定一个只包含小写字母的字符串 s。你可以重复执行以下操作任意次（也可以不

package main

import (
    "fmt"
)

func lexSmallestAfterDeletion(s string)string {
    left := [26]int{}
    for _, ch := range s {
        left[ch-'a']++
    }

    st := []rune{}
    for _, ch := range s {
        // 如果 ch 比栈顶小，移除栈顶，可以让字典序更小
        forlen(st) > 0 && ch < st[len(st)-1] && left[st[len(st)-1]-'a'] > 1 {
            left[st[len(st)-1]-'a']--
            st = st[:len(st)-1]
        }
        st = append(st, ch)
    }

    // 最后，移除末尾的重复字母，可以让字典序更小
    for left[st[len(st)-1]-'a'] > 1 {
        left[st[len(st)-1]-'a']--
        st = st[:len(st)-1]
    }

    returnstring(st)
}

func main() {
    s := "aaccb"
    result := lexSmallestAfterDeletion(s)
    fmt.Println(result)
}

# -*-coding:utf-8-*-

def lex_smallest_after_deletion(s: str) -> str:
    left = [0] * 26
    for ch in s:
        left[ord(ch) - ord('a')] += 1

    stack = []
    for ch in s:
        # 如果 ch 比栈顶小，移除栈顶，可以让字典序更小
        while stack and ch < stack[-1] and left[ord(stack[-1]) - ord('a')] > 1:
            left[ord(stack[-1]) - ord('a')] -= 1
            stack.pop()
        stack.append(ch)

    # 最后，移除末尾的重复字母，可以让字典序更小
    while left[ord(stack[-1]) - ord('a')] > 1:
        left[ord(stack[-1]) - ord('a')] -= 1
        stack.pop()

    return''.join(stack)


if __name__ == "__main__":
    s = "aaccb"
    result = lex_smallest_after_deletion(s)
    print(result)

#include <iostream>
#include <string>
#include <vector>
#include <stack>

using namespace std;

string lexSmallestAfterDeletion(string s) {
    vector<int> left(26, 0);
    for (char ch : s) {
        left[ch - 'a']++;
    }

    vector<char> st;
    for (char ch : s) {
        // 如果 ch 比栈顶小，移除栈顶，可以让字典序更小
        while (!st.empty() && ch < st.back() && left[st.back() - 'a'] > 1) {
            left[st.back() - 'a']--;
            st.pop_back();
        }
        st.push_back(ch);
    }

    // 最后，移除末尾的重复字母，可以让字典序更小
    while (left[st.back() - 'a'] > 1) {
        left[st.back() - 'a']--;
        st.pop_back();
    }

    returnstring(st.begin(), st.end());
}

int main() {
    string s = "aaccb";
    string result = lexSmallestAfterDeletion(s);
    cout << result << endl;
    return0;
}