C. Unusual Competitions
time limit per test1 second
memory limit per test512 megabytes
inputstandard input
outputstandard output
A bracketed sequence is called correct (regular) if by inserting “+” and “1” you can get a well-formed mathematical expression from it. For example, sequences “(())()”, “()” and “(()(()))” are correct, while “)(”, “(()” and “(()))(” are not.

The teacher gave Dmitry’s class a very strange task — she asked every student to come up with a sequence of arbitrary length, consisting only of opening and closing brackets. After that all the students took turns naming the sequences they had invented. When Dima’s turn came, he suddenly realized that all his classmates got the correct bracketed sequence, and whether he got the correct bracketed sequence, he did not know.

Dima suspects now that he simply missed the word “correct” in the task statement, so now he wants to save the situation by modifying his sequence slightly. More precisely, he can the arbitrary number of times (possibly zero) perform the reorder operation.

The reorder operation consists of choosing an arbitrary consecutive subsegment (substring) of the sequence and then reordering all the characters in it in an arbitrary way. Such operation takes l nanoseconds, where l is the length of the subsegment being reordered. It’s easy to see that reorder operation doesn’t change the number of opening and closing brackets. For example for “))((” he can choose the substring “)(” and do reorder “)()(” (this operation will take 2 nanoseconds).

Since Dima will soon have to answer, he wants to make his sequence correct as fast as possible. Help him to do this, or determine that it’s impossible.

Input
The first line contains a single integer n (1≤n≤106) — the length of Dima’s sequence.

The second line contains string of length n, consisting of characters “(” and “)” only.

Output
Print a single integer — the minimum number of nanoseconds to make the sequence correct or “-1” if it is impossible to do so.

Examples
inputCopy
8
))((())(
outputCopy
6
inputCopy
3
(()
outputCopy
-1
Note
In the first example we can firstly reorder the segment from first to the fourth character, replacing it with “()()”, the whole sequence will be “()()())(”. And then reorder the segment from the seventh to eighth character, replacing it with “()”. In the end the sequence will be “()()()()”, while the total time spent is 4+2=6 nanoseconds.

题意：给了长度为n的字符串，只有左右括号，你可以进行任意次选择
选择连续的k个字符，对他们随意排序需要花费k个精力，问满足题中要求最少要多少个精力

思路：考虑下 如果第一个进的是左括号，那么根据题中满足的序列，只要一直计算左右括号个数就可以了，相等时候就置0，思考一下 因为可能是() 这样就直接置0 要么就是(()) 要么(()()) 只要左括号先进 后面一旦个数一样 就一定是满足要求的
接下来考虑下右括号先进，右括号先进的话，也是进行左右括号个数统计，一直到相等，整个是都需要重新排序的
然后模拟过程即可

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define me(a,x) memset(a,x,sizeof a)
#define rep(i,x,n) for(int i=x;i<n;i++)
#define repd(i,x,n) for(int i=x;i<=n;i++)
#define all(x) (x).begin(), (x).end()
#define pb(a) push_back(a)
#define paii pair<int,int>
#define pali pair<ll,int>
#define pail pair<int,ll>
#define pall pair<ll,ll>
#define fi first
#define se second
int main()
{
   int n;
   string s;
   cin>>n>>s;
   int ans=0;
   int l=0,r=0,flag=0;
   for(int i=0;i<n;i++){
       if(!flag){

           if(s[i]=='(') l++,flag=1;
           else r++,flag=2;
       }
       else if(flag==1){

           if(s[i]=='(') l++;
           else r++;
          if(l==r) l=r=flag=0;
       }
       else
       {
           if(s[i]=='(') l++;
           else r++;
           if(l==r) ans+=l*2,l=r=flag=0;
       }
   }
   if(l!=r) puts("-1");
   else cout<<ans<<endl;

   return 0;
}