Flipping Parentheses~Gym 100803G

Description

A string consisting only of parentheses ‘(’ and ‘)’ is called balanced if it is one of the following.

A string “()” is balanced.
Concatenation of two balanced strings are balanced.
When a string s is balanced, so is the concatenation of three strings “(”, s, and “)” in this order.

Note that the condition is stronger than merely the numbers of ‘(’ and ‘)’ are equal. For instance, “())(()” is not balanced.

Your task is to keep a string in a balanced state, under a severe condition in which a cosmic ray may flip the direction of parentheses.

You are initially given a balanced string. Each time the direction of a single parenthesis is flipped, your program is notified the position of the changed character in the string. Then, calculate and output the leftmost position that, if the parenthesis there is flipped, the whole string gets back to the balanced state. After the string is balanced by changing the parenthesis indicated by your program, next cosmic ray flips another parenthesis, and the steps are repeated several times.

Input

The input consists of a single test case formatted as follows.

N Qsq1⋮qQN Qsq1⋮qQ

The first line consists of two integers N and Q (2 ≤ N ≤ 300000, 1 ≤ Q ≤ 150000). The second line is a string s of balanced parentheses with length N. Each of the following Q lines is an integer qi (1 ≤ qi ≤ N) that indicates that the direction of the qi-th parenthesis is flipped.

Output

For each event qi, output the position of the leftmost parenthesis you need to flip in order to get back to the balanced state.

Note that each input flipping event qi is applied to the string after the previous flip qi − 1 and its fix.

Sample Input

6 3

((()))

4

3

1

20 9

()((((()))))()()()()

15

20

13

5

3

10

3

17

18

Sample Output

Hint

In the first sample, the initial state is “((()))”. The 4th parenthesis is flipped and the string becomes “(((())”. Then, to keep the balance you should flip the 2nd parenthesis and get “()(())”. The next flip of the 3rd parenthesis is applied to the last state and yields “())())”. To rebalance it, you have to change the 2nd parenthesis again yielding “(()())”.

这题简直爆炸，知道感觉需要用线段树维护，但是不知道查询，而且我线段树血都写不出了

好久好久没有写过线段树了，板子都不会了，更别说应用了。

题意：就是给你一个匹配好的括号串长度为n，在给你m个操作，每个操作就给翻转摸一个位置的括号，

对于每一个操作，你要找到一括号将其翻转，使得最后这个串还是匹配的，

若存在多个解，翻转最左边的那个括号。

（为 1，）为-1 ，然后容易联想到前缀和，

然后就是用线段树去维护这个前缀和，

如果是 x = ) 就是找到第一个）这个相对简单，用set和线段树都可以做

如果是 x = （就是从左到右找到第一个（这个就只能用线段树实现了

记录了前缀和，其实只要找到一段区间的最小值都大于1就行了；

这个就是整个线段树最难的部分了，

int query1(int rt, int L, int R) {
if (L == R) return L + 1;
int mid = (L + R) >> 1;
pushdown(rt);
if (tree[rt << 1 | 1].r < 2 ) query1(rt << 1 | 1, mid + 1, R);
else query1(rt << 1, L, mid);

}

当时的我怎么也想不出。太菜了；

注意每一个找到了y 记得更新 y

 #include<iostream>

 #include<algorithm>

 #include<cstring>

 #include<cstdio>

 using namespace std;

 const int maxn = 3e5 + ;

 char s[maxn];

 int  sum[maxn];

 struct node {

     int l, r, add;

 } tree[maxn * ];

 int fun(int i) {

     return s[i] == '(' ?  : -;

 }

 void pushup(int rt) {

     tree[rt].l = min(tree[rt <<  | ].l, tree[rt << ].l);

     tree[rt].r = min(tree[rt <<  | ].r, tree[rt << ].r);

 }

 void pushdown(int rt) {

     tree[rt << ].l       += tree[rt].add;

     tree[rt << ].r       += tree[rt].add;

     tree[rt << ].add     += tree[rt].add;

     tree[rt <<  | ].l   += tree[rt].add;

     tree[rt <<  | ].r   += tree[rt].add;

     tree[rt <<  | ].add += tree[rt].add;

     tree[rt].add = ;

 }

 void build(int rt, int L, int R) {

     tree[rt].add = ;

     if (L == R) {

         tree[rt].l = sum[L] - L;

         tree[rt].r = sum[L];

         return ;

     }

     int mid = (L + R) >> ;

     build(rt << , L, mid);

     build(rt <<  | , mid + , R );

     pushup(rt);

 }

 void updata(int rt, int L, int R, int x, int add) {

     if (x <= L) {

         tree[rt].add += add;

         tree[rt].l  += add;

         tree[rt].r  += add;

         return ;

     }

     pushdown(rt);

     int mid = (L + R) >> ;

     if (x <= mid) updata(rt << , L, mid, x, add);

     updata(rt <<  | , mid + , R, x, add);

     pushup(rt);

 }

 int query1(int rt, int L, int R) {

     if (L == R) return L  + ;

     int mid = (L + R) >> ;

     pushdown(rt);

     if (tree[rt <<  | ].r <  ) query1(rt <<  | , mid + , R);

     else query1(rt << , L, mid);

 }

 int query2(int rt, int L, int R) {

     if (L == R )  return L;

     int mid = (L + R) / ;

     pushdown(rt);

     if (tree[rt << ].l <  ) query2(rt << , L, mid);

     else query2((rt << ) + , mid + , R) ;

 }

 int main() {

     int n, q, len, x, y;

     while(scanf("%d%d", &n, &q) != EOF) {

         s[] = '';

         memset(sum, , sizeof(sum));

         scanf("%s", s + );

         len = strlen(s) - ;

         for (int i =  ; i <= len ; i++)

             sum[i] = sum[i - ] + fun(i);

         build(, , len);

         for (int i =  ; i <= q ; i++) {

             scanf("%d", &x);

             s[x] = (s[x] == '(' ? ')' : '(');

             if (s[x] == ')') updata(, , len, x, -);

             else updata(, , len, x, );

             if (s[x] == ')') y = query2(, , len);

             else y = query1(, , len);

             s[y] = (s[y] == '(' ? ')' : '(' );

             if (s[y]=='(') updata(,,len,y,);

             else updata(,,len,y,-);

             printf("%d\n", y);

         }

     }

     return ;

 }