Либо удваивая одиночные, либо заменяя сдвоенные одним символом, привести строку к заданному виду

#include <stdio.h>
#include <conio.h>
#include <string.h>
 
#include <iostream>
 
using namespace std;
 
void get_freq(const char* str, char* pchars)
{
    for (int index = 0; str[index] != '\0'; index++)
    {
        int count = 0; char ch = str[index];
        for (int nindex = index; str[nindex] != '\0'; nindex++)
            if (str[nindex] == ch) count++;
 
        if (pchars[ch] <= 0) pchars[ch] = count;
    }
}
 
void main(void)
{
    const int N = 3;
 
    char input[N][256] = { "aaaza", "aazzaa", "azzza" };
    char output[256] = "aazza";
 
    char pchars[N + 1][256] = { { 0 } };
    get_freq(output, pchars[0]);
 
    int op_cnts[3] = { 0 };
    for (char ch = 'a'; ch <= 'z'; ch++)
    {
        int count = -1;
        if ((count = pchars[0][ch]) > 0)
        {
            for (int index = 0; index < N; index++)
            {
                get_freq(input[index], pchars[index + 1]);
                if (pchars[0][ch] < pchars[index + 1][ch])
                {
                    while (pchars[0][ch] != pchars[index + 1][ch])
                    {
                        int nindex = 0; bool found = false;
                        while (input[index][nindex] != '\0' && !found)
                            if (input[index][nindex++] == ch)
                            {
                                int t_index = nindex - 1;
                                while (input[index][t_index] != '\0')
                                {
                                    input[index][t_index] = input[index][t_index + 1];
                                    t_index++;
                                }
 
                                found = true;
                            }
 
                        pchars[index + 1][ch]--; op_cnts[index]++;
                    }
                }
 
                else if (pchars[0][ch] > pchars[index + 1][ch])
                {
                    while (pchars[0][ch] != pchars[index + 1][ch])
                    {
                        int nindex = 0;
                        while (input[index][nindex] != ch &&
                            input[index][nindex] != '\0') nindex++;
 
                        int rindex = strlen(input[index]) - 1;
                        while (rindex >= nindex)
                        {
                            input[index][rindex + 1] = input[index][rindex];
                            rindex--;
                        }
 
                        pchars[index + 1][ch]++; op_cnts[index]++;
                    }
                }       
            }
        }
    }
 
    int count = 0, min_op = -1;
    for (int index = 0; index < N; index++)
        if (strcmp(input[index], output) == 0) count++;
 
    for (int index = 0; index < N && count > 0; index++)
        if ((strcmp(input[index], output) == 0 && 
            op_cnts[index] < op_cnts[min_op]) || (min_op == -1))
        {
            min_op = index;
        }
 
    if (count <= 0) std::cout << "IMPOSSIBLE" << endl;
    else std::cout << "string = " << input[min_op] << " op_count = " << op_cnts[min_op] << endl;
 
    _getch();
}

///////////////////////////////////////////////////////////////////////////////
//1.
///////////////////////////////////////////////////////////////////////////////
//Даны три строки, состоящие из строчных латинских букв. С этими строками можно
//производить следующие операции: либо заменить один символ строки на два таких же символа
//(например, заменить символ «a» на «aa»), либо, наоборот, заменить два подряд идущих
//одинаковых символа на один такой же символ.
//Необходимо при помощи этих операций сделать все три строки равными какой-то другой
//общей строке S либо определить, что это сделать невозможно. При этом нужно минимизировать
//общее количество операций.
//Программа получает на вход три строки, состоящие из строчных букв латинского алфавита.
//Длина каждой строки не превышает 100 символов.
//Если при помощи указанных операций возможно сделать все три строки равными, выведите
//такую строку S, что суммарное число операций, необходимых для преобразования всех трёх
//данных строк к строке S, будет минимальным. Если этого сделать нельзя, программа должна
//вывести одно слово IMPOSSIBLE (заглавными буквами).
//Примеры:
//Ввод:
//aaaza
//aazzaa
//azzza
//Вывод:
//aazza
 
//Ввод:
//xy
//xxyy
//yx
//Вывод:
//IMPOSSIBLE
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <iostream>
#include <iterator>
#include <set>
#include <string>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::string                     T_str;
typedef std::vector     < T_str     >   T_strings;
typedef std::multiset   < int       >   T_sizes;
///////////////////////////////////////////////////////////////////////////////
class   T_super_letter
{
    //-------------------------------------------------------------------------
    char        letter_;
    T_sizes     sizes_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    T_super_letter
        (
            char    letter,
            int     size
        )
        :
        letter_( letter )
    {
        sizes_.emplace( size );
    }
    //-------------------------------------------------------------------------
    bool    operator==  ( T_super_letter    const   &   R )                 const
    {
        return      letter_
                ==  R.letter_;
    }
    //-------------------------------------------------------------------------
    T_super_letter  &   operator+=  ( T_super_letter    const   &   R )
    {
        sizes_.insert   (
                            R.sizes_    .begin  (),
                            R.sizes_    .end    ()
                        );
 
        return  *this;
    }
    //-------------------------------------------------------------------------
    T_str   to_string()                                                     const
    {
        auto    it  =   sizes_.begin();
 
        std::advance    (
                            it,
                            sizes_.size() / 2
                        );
 
        return  T_str   (
                            *it,
                            letter_
                        );
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
typedef std::vector     < T_super_letter    >   T_super_letters;
///////////////////////////////////////////////////////////////////////////////
class   T_super_word
{
    //-------------------------------------------------------------------------
    bool                is_valid_;
    T_super_letters     super_letters_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    T_super_word    (
                        T_str   const   &   s     =   {}
                    )
        :
        is_valid_( true )
    {
        auto    it          =   s.begin();
        auto    it_next     =   s.begin();
 
        while   (
                        (
                            it_next     =   find_if
                                                (
                                                    it,
                                                    s.end(),
 
                                                    [=]  ( auto  elem )
                                                    {
                                                        return  elem    !=  *it;
                                                    }
                                                )
                        )
 
                    !=  it
                )
        {
            super_letters_.emplace_back     (
                                                T_super_letter  (
                                                                    *it,
                                                                    it_next - it
                                                                )
                                            );
 
            std::swap( it,  it_next );
        }//for
    }
    //-------------------------------------------------------------------------
    T_super_word    &   operator+=  ( T_super_word  const   &   R )
    {
        if  (
                super_letters_.empty()
            )
        {
            *this   =   R;
        }
        else
        {
            is_valid_   =       is_valid_
 
                            &&      super_letters_
                                ==  R.super_letters_;
 
            if( is_valid_ )
            {
                auto    it  =   super_letters_.begin();
 
                for( auto   const   &   sup_lett    :   R.super_letters_ )
                {
                    *it     +=  sup_lett;
                    ++it;
                }
            }//if
        }//else
 
        return  *this;
    }
    //-------------------------------------------------------------------------
    T_str   to_string()                                                     const
    {
        T_str   res;
 
        if( is_valid_ )
        {
            for( auto   const   &   sup_lett    :   super_letters_ )
            {
                res     +=  sup_lett.to_string();
            }
        }
        else
        {
            res     =   "IMPOSSIBLE";
        }
 
        return  res;
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
T_str   best_overall_line( T_strings    const   &   strings )
{
    T_super_word    res;
 
    for( auto   const   &   s   :   strings )
    {
        res     +=  T_super_word(s);
    }
 
    return  res.to_string();
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_strings   strings(3);
 
    for( auto   &   s   :   strings )
    {
        std::cin    >>  s;
    }
 
    std::cout   <<  std::endl
                <<  best_overall_line( strings )
                <<  std::endl;
}