[LeetCode] 1370. El aumento de disminución de cuerdas

1. El enlace título original: https://leetcode.com/problems/increasing-decreasing-string/

2. Ideas de resolución de problemas

1. idea intuitiva es: mapa ordenada <char, int> número de registro de letras y aparece carta
2. De la manera descrita en el título, el primer mapa de orden transversal, mapa un recorrido orden inverso, el número de veces hasta que todas las cartas en el mapa hasta la ocurrencia 0

3. Algoritmos

1. Transversal cadena s, ordenada por el mapa <char, int> el número de la grabación de las letras y las letras aparecen
2. El establecimiento de una bandera que indica la corriente directa es un delantero recorrer el mapa, o mapa de recorrido inverso
3. Recorrer el mapa, si el número de ocurrencias de la letra X no es 0, entonces el resultado añadido a la cadena de letras, el número de ocurrencias de la letra y un signo menos, de lo contrario, el número de apariciones de la letra X es 0, indica que la carta ha sido se ha atravesado, y se han añadido a la cadena de resultado
4. Si, después de un recorrido completo de un mapa, todas las ocurrencias de las letras son 0, representa la cadena completa ha sido atravesado encima, entonces se puede salir del bucle y devuelve la cadena resultante (PS: En realidad condición de salida puede ser: cuando el resultado del carácter la longitud de la cadena original y una cadena de la misma longitud, pueden salir del bucle)

4. Implementar

class Solution {
public:
    string sortString(string s) {
        map<char, int> table;
        for(auto c : s){
            table[c] = table[c] + 1;
        }
        string res;
        bool forward = 1;
        while(table.size() != 0){
            bool finish = true;
            if(forward){
                map<char, int>::iterator begin = table.begin();
                map<char, int>::iterator end = table.end();
                forward = 0;
                for(; begin != end; begin++){
                    if(begin->second == 0){
                        continue;
                    }
                    finish = false;
                    res += begin->first;
                    begin->second = begin->second - 1;
                }
            }else{
                map<char, int>::reverse_iterator begin = table.rbegin();
                map<char, int>::reverse_iterator end = table.rend();
                forward = 1;
                for(; begin != end; begin++){
                    if(begin->second == 0){
                        continue;
                    }
                    finish = false;
                    res += begin->first;
                    begin->second = begin->second - 1;
                }
            }
            if(finish)
                break;
            //if(res.size() == s.size()) //另一种退出条件
            //    break;
        }
        return res;
    }
};

//巧妙解法
//该解法有个限制条件：s中出现的字符排序规则必须跟map对这些字符的排序规则保持一致
class Solution {
public:
    string sortString(string s) {
        string ans;
        map<char,int > cnt;
        for(auto item:s)cnt[item]++;
        while(1){
           for(char ch='a';ch<='z';++ch)
                if(cnt[ch]!=0)cnt[ch]--,ans.push_back(ch);
            for(char ch='z';ch>='a';--ch)
                if(cnt[ch]!=0)cnt[ch]--,ans.push_back(ch);
            if(ans.size()==s.size())break;
        }
        return ans;
    }
};