Codeforces Round #288 (Div. 2) E. Arthur and Brackets [dp 贪心]

E. Arthur and Brackets

time limit per test

2 seconds

memory limit per test

128 megabytes

input

standard input

output

standard output

Notice that the memory limit is non-standard.

Recently Arthur and Sasha have studied correct bracket sequences. Arthur understood this topic perfectly and become so amazed about correct bracket sequences, so he even got himself a favorite correct bracket sequence of length 2n. Unlike Arthur, Sasha understood the topic very badly, and broke Arthur's favorite correct bracket sequence just to spite him.

All Arthur remembers about his favorite sequence is for each opening parenthesis ('(') the approximate distance to the corresponding closing one (')'). For the i-th opening bracket he remembers the segment [l_i, r_i], containing the distance to the corresponding closing bracket.

Formally speaking, for the i-th opening bracket (in order from left to right) we know that the difference of its position and the position of the corresponding closing bracket belongs to the segment [l_i, r_i].

Help Arthur restore his favorite correct bracket sequence!

Input

The first line contains integer n (1 ≤ n ≤ 600), the number of opening brackets in Arthur's favorite correct bracket sequence.

Next n lines contain numbers l_i and r_i (1 ≤ l_i ≤ r_i < 2n), representing the segment where lies the distance from the i-th opening bracket and the corresponding closing one.

The descriptions of the segments are given in the order in which the opening brackets occur in Arthur's favorite sequence if we list them from left to right.

Output

If it is possible to restore the correct bracket sequence by the given data, print any possible choice.

If Arthur got something wrong, and there are no sequences corresponding to the given information, print a single line "IMPOSSIBLE" (without the quotes).

Sample test(s)

Input

4
1 1
1 1
1 1
1 1

Output

()()()()

Input

3
5 5
3 3
1 1

Output

((()))

Input

3
5 5
3 3
2 2

Output

IMPOSSIBLE

Input

3
2 3
1 4
1 4

Output

(())()

一把一把的泪啊，，，看错题搞了很久，，，然后dp时输出串也搞了很久，，，原来水水的贪心就能过，，，泪流满面，

转一下贪心的思路： http://www.cnblogs.com/wuyuewoniu/p/4256013.html

CF上给这道题打了dp和greedy两个标签，应该是两种做法都可以吧。下面说贪心的做法。

题意：

有一些配好对的括号，现在已知第i对括号，左右括号的距离在[L_i, R_i]区间中。按照左括号出现的顺序编号。

输出原括号序列。

分析：

因为括号是以栈的形式配对的，所以我们将这些区间也以栈的形式存储。

假设第i对括号的左括号在位置p，则右括号只能在[p+L_i, p+R_i]这个区间中。

每放一个左括号，就将右括号对应的区间入栈。

贪心的办法是，如果当前位置位于栈顶区间的范围内，则尽早入栈。

贪心的理由是：因为早点使栈顶的括号配对，就有更大的机会使栈顶的第二队括号配上对。

 #include<iostream>
 #include<cstring>
 #include<cstdlib>
 #include<cstdio>
 #include<algorithm>
 #include<cmath>
 #include<queue>
 #include<map>
 #include<set>
 #include<stack>
 #include<string>

 #define N 1205
 #define M 105
 #define mod 1000000007
 //#define p 10000007
 #define mod2 1000000000
 #define ll long long
 #define LL long long
 #define eps 1e-6
 #define inf 100000000
 #define maxi(a,b) (a)>(b)? (a) : (b)
 #define mini(a,b) (a)<(b)? (a) : (b)

 using namespace std;

 int n;
 char s[N];
 int l[N],r[N];
 int flag;
 int dp[][];

 void ini()
 {
     memset(dp,-,sizeof(dp));
     int i;
     for(i=;i<=n;i++){
         scanf("%d%d",&l[i],&r[i]);
     }
     flag=;
     s[*n]='\0';
 }

 int fun(int now,int tot,int st,int en)
 {
    // printf("now=%d tot=%d st=%d en=%d\n",now,tot,st,en);
     int f1,f2;
     int i;
     int tot1,tot2;
     int ss,ee;
     if(dp[now][tot]!=-){
         return dp[now][tot];
     }
     if(tot==){
         if(l[now]==){
             dp[now][tot]=;
             return ;
         }
         else{
             dp[now][tot]=;
             return ;
         }
     }
     ss=l[now];ee=r[now];
     if(ss%==) ss++;
     if(ee%==) ee--;
     for(i=ss;i<=min(ee,en-st);i+=){
         tot1=(i+)/;
         tot2=tot-tot1;
         //printf(" i=%d tot1=%d tot2=%d\n",i,tot1,tot2);
         if(tot2<) break;
         if(tot1==){
             f2=fun(now+,tot2,st+,en);
             if(f2>=){
                 dp[now][tot]=;
                 return ;
             }
         }
         else if(tot1==tot){
             f1=fun(now+,tot1-,st+,en-);
             if(f1>=){
                 dp[now][tot]=i;
                 return ;
             }
         }
         else{
             f1=fun(now+,tot1-,st+,st+i-);
             f2=fun(now+tot1,tot2,st+i+,en);
             if(f1>= && f2>=){
                 dp[now][tot]=i;
                 return ;
             }
         }
     }
     dp[now][tot]=;
     return ;
 }

 void solve()
 {
     flag=fun(,n,,*n);
 }

 void print(int now,int tot)
 {
     int tot1,tot2;
     tot1=(dp[now][tot]+)/;
     tot2=tot-tot1;
     printf("(");
     if(tot1!=)
         print(now+,tot1-);
     printf(")");
     if(tot1!=tot)
         print(now+tot1,tot2);

 }

 void out()
 {
    /* int i,j;
     printf("flag=%d\n",flag);
     for(i=1;i<=n;i++){
         for(j=1;j<=n;j++){
             printf(" i=%d j=%d dp=%d\n",i,j,dp[i][j]);
         }
     }*/
     if(flag==){
         printf("IMPOSSIBLE\n");
     }
     else{
         print(,n);
         printf("\n");
         //printf("%s\n",s);
     }
 }

 int main()
 {
     //freopen("data.in","r",stdin);
     //freopen("data.out","w",stdout);
     //scanf("%d",&T);
     //for(int ccnt=1;ccnt<=T;ccnt++)
     //while(T--)
     while(scanf("%d",&n)!=EOF)
     {
         ini();
         solve();
         out();
     }
     return ;
 }