Сколько нужно убрать из данной последовательности скобок, чтобы получить правильную последовательность?

#include <iostream>
#include <string>
 
int main() {
    //std::string expression("((())(())))))");
    std::string expression("())(()");
    int count=0; // для открывающих ++, для закрывающих --
    int error=0; // число скобок на удаление
 
    for(size_t i=0; i<expression.size(); i++) {
        if(expression[i] == '(') { // открывающая, значит ++
            count++;
            continue;
        }
        if(expression[i] == ')') { // закоывающая
            if(count==0) // если все открывающие обеспечены
                error++; // ошибка
            else
                count--; // иначе обеспечиваем открывающую
        }
    }
    error+=count; // добавляем число не обеспеченных открытых
 
    std::cout << "error = " << error << std::endl;
    return 0;
}

#include <iostream>
 
 using namespace std;
 
int main() {
    int counterIn = 0;
    int counterOut = 0;
    char sign;
    
    for ( ; cin >> sign && sign != '\0'; ) {
        if ( sign == '(' ) {
            counterIn += 1;
        }
        if ( sign == ')' ) {
            counterOut += 1;
        }
    }
    counterIn -= counterOut;
    
    if ( counterIn < 0 ) {
        counterIn *= -1;
    }
    
    cout << counterIn << endl;
    
    return 0;
}

#include <iostream>
#include <string>
 
using namespace std;
int main()
{
    setlocale(0,"Rus");
    char str[255];
    int count=0;
    cout<<"Ââåäèòå ñòðîêó: ";
    cin>>str;
    for (int i=0; i<strlen(str); i++)
    {
        if (str[i]=='(' && str[i+1]==')')
           count--;
        else count++;
    }
    cout<<count<<endl;
    system("pause");
    return 0;
}

for (int i=0; i<strlen(str); i++)

if (str[i]=='(' && str[i+1]==')')

if (str[3]=='(' && str[4]==')')

#include <string>
#include <stack>
#include <iostream>  
using namespace std;
int main(){
    int cnt=0;
    string str;
    stack<int> stk;
    getline(cin, str);
    for (int i=0; i<str.size(); ++i){
       if (str[i]=='('){
            stk.push(i);
            continue;
       }
       if (str[i]==')'){
            if (stk.empty()) ++cnt;
            else             stk.pop();
       }
    }
    cnt+=stk.size();
    cout<<cnt;
    return 0;
}

/////////////////////////////////////////////////////////////////////////////////////////
//Сколько надо убрать скобок из данной последовательности скобок чтобы получить правильную 
//последовательность?
//К примеру ())(() ответ 2
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <ctime>
#include <iostream>
#include <iterator>
#include <random>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
const   char    LEFT_BRACKET    =   '(';
const   char    RIGHT_BRACKET   =   ')';
const   char    SPACE_SYMB      =   ' ';
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                             T_str;
typedef T_str::size_type                        T_pos;
typedef std::uniform_int_distribution< char >   T_char_distribution;
/////////////////////////////////////////////////////////////////////////////////////////
T_str   get_rand_brackets_sequence_with_len( int    len )
{
    static  std::default_random_engine  rand_generator      (   unsigned(time(0))               );
    static  T_char_distribution         char_distribution   (   LEFT_BRACKET,   RIGHT_BRACKET   );
 
    T_str   res;
 
    std::generate_n
        (
            std::back_inserter( res ),
            len,
 
            [&] ()
            {
                return  char_distribution( rand_generator );
            }
        );
 
    return  res;
}
/////////////////////////////////////////////////////////////////////////////////////////
void    for_brackets_sequence_set_extra_brackets_and_correct_sequence_and_counter
    (
        T_str   const   &   brackets_sequence,
        T_str           &   extra_brackets,
        T_str           &   correct_brackets_sequence,
        int             &   correct_brackets_counter
    )
{
    extra_brackets  =   brackets_sequence;
 
    correct_brackets_sequence   =   T_str   (
                                                brackets_sequence.size(),
                                                SPACE_SYMB
                                            );
 
    correct_brackets_counter    =   0;
 
    for( size_t  substr_len = 2; substr_len <= brackets_sequence.size(); substr_len += 2 )
    {
        T_str   substr  (
                            substr_len,
                            SPACE_SYMB
                        );
 
        substr.front    ()  =   LEFT_BRACKET;
        substr.back     ()  =   RIGHT_BRACKET;
 
        for(;;)
        {
            auto    pos     =   extra_brackets.find( substr );
 
            if( pos     ==  T_str::npos )
            {
                break;
            }
 
            correct_brackets_counter    +=  2;
 
            extra_brackets.replace              ( pos,                      1,  1,  SPACE_SYMB      );
            extra_brackets.replace              ( pos + substr_len - 1,     1,  1,  SPACE_SYMB      );
 
            correct_brackets_sequence.replace   ( pos,                      1,  1,  LEFT_BRACKET    );
            correct_brackets_sequence.replace   ( pos + substr_len - 1,     1,  1,  RIGHT_BRACKET   );
        }//for
    }//for
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    const   int     RAND_BRACKETS_SEQ_LEN   =   10;
 
    for(;;)
    {
        T_str   rand_brackets_sequence      =   get_rand_brackets_sequence_with_len( RAND_BRACKETS_SEQ_LEN );
        T_str   extra_brackets;
        T_str   correct_brackets_sequence;
        int     correct_brackets_counter    =   0;
 
        for_brackets_sequence_set_extra_brackets_and_correct_sequence_and_counter
            (
                rand_brackets_sequence,
                extra_brackets,
                correct_brackets_sequence,
                correct_brackets_counter
            );
 
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  "В последовательности скобок"
                    <<  std::endl
                    <<  rand_brackets_sequence
                    <<  std::endl
                    <<  "нужно убрать скобки "
                    <<  std::endl
                    <<  extra_brackets
                    <<  std::endl
                    <<  "в количестве "
                    <<  RAND_BRACKETS_SEQ_LEN - correct_brackets_counter
                    <<  ", чтобы получить корректную последовательность "
                    <<  std::endl
                    <<  correct_brackets_sequence
                    <<  std::endl;
 
        system("pause");
    }//for
}

/////////////////////////////////////////////////////////////////////////////////////////
//Сколько надо убрать скобок из данной последовательности скобок чтобы получить правильную 
//последовательность?
//К примеру ())(() ответ 2
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <ctime>
#include <iostream>
#include <iterator>
#include <random>
#include <stack>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
const   char    LEFT_BRACKET    =   '(';
const   char    RIGHT_BRACKET   =   ')';
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                             T_str;
typedef std::uniform_int_distribution< char >   T_char_distribution;
/////////////////////////////////////////////////////////////////////////////////////////
T_str   get_rand_brackets_sequence_with_len( int    len )
{
    static  std::default_random_engine  rand_generator          (   unsigned(time(0))               );
    static  T_char_distribution         brackets_distribution   (   LEFT_BRACKET,   RIGHT_BRACKET   );
 
    T_str   res;
 
    std::generate_n
        (
            std::back_inserter  ( res ),
            len,
 
            [&]                 ()
            {
                return  brackets_distribution( rand_generator );
            }
        );
 
    return  res;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     count_extra_brackets( T_str   const   &   brackets_sequence )
{
    std::stack< char >  stack;
 
    std::for_each
        (
            brackets_sequence.begin     (),
            brackets_sequence.end       (),
 
            [&]                         ( char  c )
            {
                if  (
                            c                   ==  RIGHT_BRACKET
                        &&  !stack.empty    ()
                        &&  stack.top       ()  ==  LEFT_BRACKET
                    )
                {
                    stack.pop   ();
                }
                else
                {
                    stack.push  ( c );
                }
            }
        );
 
    return  stack.size();
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    const   int     RAND_BRACKETS_SEQ_LEN   =   10;
 
    for(;;)
    {
        T_str   rand_brackets_sequence      =   get_rand_brackets_sequence_with_len( RAND_BRACKETS_SEQ_LEN );
 
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  "В последовательности скобок"
                    <<  std::endl
                    <<  rand_brackets_sequence
                    <<  std::endl
                    <<  "нужно убрать "
                    <<  count_extra_brackets( rand_brackets_sequence )
                    <<  " скобок, чтобы получить корректную последовательность."
                    <<  std::endl;
 
        system("pause");
    }//for
}