Programa C++ para eliminar recursivamente todos los duplicados adyacentes

Dada una string, elimine recursivamente los caracteres duplicados adyacentes de la string. La string de salida no debe tener duplicados adyacentes. Vea los siguientes ejemplos.

Ejemplos : 

Entrada : azxxzy 
Salida : ay 
Primero, “axxxzy” se reduce a “azzy”. 
La string «azzy» contiene duplicados, 
por lo que se reduce aún más a «ay».

Entrada : geeksforgeeg 
Salida : gksfor 
Primero, “geeksforgeeg” se reduce a 
“gksforgg”. La string «gksforgg» 
contiene duplicados, por lo que se 
reduce aún más a «gksfor».

Entrada : caaabbbaacdddd 
Salida : String vacía

Entrada : acaaabbbacdddd 
Salida : acac 

Se puede seguir el siguiente enfoque para eliminar duplicados en tiempo O(N) : 

• Comience desde el carácter más a la izquierda y elimine los duplicados en la esquina izquierda si hay alguno.
• El primer carácter debe ser diferente de su adyacente ahora. Recur para string de longitud n-1 (string sin primer carácter).
• Deje que la string obtenida después de reducir la substring derecha de longitud n-1 sea rem_str . Hay tres casos posibles 
  1. Si el primer carácter de rem_str coincide con el primer carácter de la string original, elimine el primer carácter de rem_str .
  2. Si la string restante se vacía y el último carácter eliminado es el mismo que el primer carácter de la string original. Devuelve una string vacía.
  3. De lo contrario, agregue el primer carácter de la string original al comienzo de rem_str .
• Devuelve rem_str .

La imagen de abajo es una ejecución en seco del enfoque anterior:

A continuación se muestra la implementación del enfoque anterior:

// C/C++ program to remove all 
// adjacent duplicates from a string
#include <iostream>
#include <string.h>
  
using namespace std;
  
// Recursively removes adjacent 
// duplicates from str and returns
// new string. las_removed is a 
// pointer to last_removed character
char* removeUtil(char *str, 
                 char *last_removed)
{    
    // If length of string is 1 or 0
    if (str[0] == '' || str[1] == '')
        return str;
  
    // Remove leftmost same characters 
    // and recur for remaining 
    // string
    if (str[0] == str[1])
    {
        *last_removed = str[0];
        while (str[1] && str[0] == str[1])
            str++;
        str++;
        return removeUtil(str, last_removed);
    }
  
    // At this point, the first character 
    // is definiotely different 
    // from its adjacent. Ignore first 
    // character and recursively 
    // remove characters from remaining string
    char* rem_str = removeUtil(str+1, 
                               last_removed);
  
    // Check if the first character 
    // of the rem_string matches with 
    // the first character of the 
    // original string
    if (rem_str[0] && rem_str[0] == str[0])
    {
        *last_removed = str[0];
        
        // Remove first character
        return (rem_str+1); 
    }
  
    // If remaining string becomes 
    // empty and last removed character
    // is same as first character of 
    // original string. This is needed
    // for a string like "acbbcddc"
    if (rem_str[0] == '' && 
                 *last_removed == str[0])
        return rem_str;
  
    // If the two first characters 
    // of str and rem_str don't match, 
    // append first character of str 
    // before the first character of
    // rem_str. 
    rem_str--;
    rem_str[0] = str[0];
    return rem_str;
}
  
// Function to remove
char *remove(char *str)
{
    char last_removed = '';
    return removeUtil(str, &last_removed);
}
  
// Driver program to test 
// above functions
int main()
{
    char str1[] = "geeksforgeeg";
    cout << remove(str1) << endl;
  
    char str2[] = "azxxxzy";
    cout << remove(str2) << endl;
  
    char str3[] = "caaabbbaac";
    cout << remove(str3) << endl;
  
    char str4[] = "gghhg";
    cout << remove(str4) << endl;
  
    char str5[] = "aaaacddddcappp";
    cout << remove(str5) << endl;
  
    char str6[] = "aaaaaaaaaa";
    cout << remove(str6) << endl;
  
    char str7[] = "qpaaaaadaaaaadprq";
    cout << remove(str7) << endl;
  
    char str8[] = "acaaabbbacdddd";
    cout << remove(str8) << endl;
  
    char str9[] = "acbbcddc";
    cout << remove(str9) << endl;
  
    return 0;
}

Producción: 

gksfor
ay
g
a
qrq
acac
a

Complejidad de tiempo: la complejidad de tiempo de la solución se puede escribir como T(n) = T(nk) + O(k) donde n es la longitud de la string de entrada y k es el número de primeros caracteres que son iguales. La solución de la recurrencia es O(n)

Gracias a Prachi Bodke por sugerir este problema y la solución inicial. 

Otro enfoque:
la idea aquí es verificar si String remStr tiene el carácter repetido que coincide con el último carácter de la string principal. Si eso sucede, debemos seguir eliminando ese carácter antes de concatenar string s y string remStr.

A continuación se muestra la implementación del enfoque anterior:

// C++ Program for above approach
#include <bits/stdc++.h>
using namespace std;
  
// Recursively removes adjacent 
// duplicates from str and returns 
// new string. las_removed is a 
// pointer to last_removed character
string removeDuplicates(string s,
                        char ch)
{
    // If length of string is 1 or 0
    if (s.length() <= 1) 
   {
        return s;
    }
  
    int i = 0;
    while (i < s.length()) 
    {
        if (i + 1 < s.length() && 
            s[i] == s[i + 1]) 
        {
            int j = i;
            while (j + 1 < s.length() && 
                   s[j] == s[j + 1]) 
            {
                j++;
            }
            char lastChar = i > 0 ? s[i - 1] : ch;
  
            string remStr = removeDuplicates(
                   s.substr(j + 1, s.length()), lastChar);
  
            s = s.substr(0, i);
            int k = s.length(), l = 0;
  
            // Recursively remove all the adjacent
            // characters formed by removing the
            // adjacent characters
            while (remStr.length() > 0 && 
                   s.length() > 0 && 
                   remStr[0] == s[s.length() - 1]) 
            {
                // Have to check whether this is the
                // repeated character that matches the
                // last char of the parent String
                while (remStr.length() > 0 && 
                       remStr[0] != ch && 
                       remStr[0] == s[s.length() - 1]) 
                {
                    remStr = remStr.substr(1, 
                             remStr.length());
                }
                s = s.substr(0, s.length() - 1);
            }
            s = s + remStr;
            i = j;
        }
        else 
        {
            i++;
        }
    }
    return s;
}
  
// Driver Code
int main()
{
    string str1 = "mississipie";
    cout << removeDuplicates(str1, ' ') << 
            endl;
  
    string str2 = "ocvvcolop";
    cout << removeDuplicates(str2, ' ') << 
            endl;
}
// This code is contributed by nirajgusain5

Producción:

mpie
lop

Complejidad de tiempo: O(n) 

Consulte el artículo completo sobre Eliminación recursiva de todos los duplicados adyacentes para obtener más detalles.