 # CLBRKT (The way I solved it and perhaps a clearer explanation)

problem link: `[https://www.codechef.com/problems/CLBRKT](https://www.codechef.com/problems/CLBRKT)`

[note: my solution is NOT UNIQUE. If you’ve read the editorial, you’ll find my approach quite similar. But I’m still writing it because for some, the editorial might be slightly unclear. (At least for me!)]

Short description: The problem gives you a bracket sequence S and Q number of queries t_i. For each t_i, you have to check if it is possible to form a complete bracket sequence using all the characters S[t_i],S[t_i +1],… S[|S|] . Here |S| means length of S. If not possible, print -1. Else, find the minimum index j such that S[t_1],S[t_i +1]…S[j] is a complete bracket sequence.We can omit some closing parenthesis but not opening parenthesis.

HOW TO SOLVE: Indeed this is a good implementation of stack. You must be familiar with the technique of checking the validity of a bracket sequence using stack.
If not… https://www.geeksforgeeks.org/check-for-balanced-parentheses-in-an-expression/

Now here’s what er do… we take a stack st and an array prec. Initially all the value of prec will be -1.

Now we do the sequence checking technique. But with a slight twist!
We traverse the sequence. If we get an opening bracket, we push ITS INDEX to the stack. Else, if we get a closing bracket and the stack is empty, there’s nothing we can do. But if not,
say, the index of the opening parenthesis is cur and we surely know that the top of the stack has the index of the nearest opening parenthesis. Say top of the stack is top. What we do now is that, prec[cur]=cur+1, prec[top]=cur+1. This means that if we are at position cur or at top, the nearest position to get a complete bracket sequence is cur+1 since it is 1- based.
Our job is almost done. But problem also says that we can omit some closing parenthesis. so what about that? Simple. We traverse the array prec backwards. Let a variable be id=-1. If we get a opening parenthesis at index i, we set id=prec[i].
Else prec[i]=id. This is because if we start from a closing parenthesis, we need to go to the nearest opening parenthesis and the find our result. So after calculating the results, we forward the results of the opening brackets to its nearest previous opening bracket.
That’s it!

Python solution:

Summary
``````def solve():

s=input()

stack=[]

dp=[-1]*(len(s))

for cur in range(len(s)):

if s[cur]=='(':

stack.append(cur+1)

else:

if len(stack)==0:

continue

d=stack[-1]-1

dp[cur]=cur+1

dp[d]=cur+1

stack.pop()

ln=len(s)

cur=-1

for n in range(ln-1,-1,-1):

if s[n]==')':dp[n]=cur

else:cur=dp[n]

(input())

s=list(map(int,input().split()))

for n in s:

print(dp[n-1])

for n in range(int(input())):solve()
``````
3 Likes