codeforces（Intel Code Challenge Elimination Round (Div.1 + Div.2, combined) ）（C，D）

You are given an array consisting of n non-negative integers a₁, a₂, ..., a_n.

You are going to destroy integers in the array one by one. Thus, you are given the permutation of integers from 1 to n defining the order elements of the array are destroyed.

After each element is destroyed you have to find out the segment of the array, such that it contains no destroyed elements and the sum of its elements is maximum possible. The sum of elements in the empty segment is considered to be 0.

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the length of the array.

The second line contains n integers a₁, a₂, ..., a_n (0 ≤ a_i ≤ 10⁹).

The third line contains a permutation of integers from 1 to n — the order used to destroy elements.

Output

Print n lines. The i-th line should contain a single integer — the maximum possible sum of elements on the segment containing no destroyed elements, after first i operations are performed.

Examples

Input

4
1 3 2 5
3 4 1 2

Output

Input

5
1 2 3 4 5
4 2 3 5 1

Output

Input

8
5 5 4 4 6 6 5 5
5 2 8 7 1 3 4 6

Output

Note

思路：并查集；

倒着来做，每次我们向原来的序列中加点，那么我们如果知道他的左边i-1和右边i+1，是否已经存在，那么我们就可以将他们合并，这个用并查集维护就可以了，然后，用当前加入的点，所构成的段去更新最大值即可。

 1 #include<stdio.h>
 2 #include<algorithm>
 3 #include<iostream>
 4 #include<string.h>
 5 #include<queue>
 6 #include<set>
 7 #include<math.h>
 8 #include<map>
 9 using namespace std;
10 typedef long long LL;
11 LL ans[100005];
12 int bns[100005];
13 int bin[100005];
14 int du[100005];
15 LL ask[100005];
16 bool flag[100005];
17 LL cost[100005];
18 int main(void)
19 {
20     int n;
21     scanf("%d",&n);
22     {
23         int i,j;memset(cost,0,sizeof(cost));
24         for(i = 1; i <= n; i++)
25         {
26             scanf("%lld",&ans[i]);
27         }
28         for(i = 1; i <= n; i++)
29         {
30             scanf("%d",&bns[i]);
31         }
32         for(i = 0; i <= 100000; i++)
33         {
34             bin[i] = i;
35             du[i] = 1;
36         }
37         LL maxx = 0;
38         for(i = n; i >= 1; i--)
39         {
40             ask[i] = maxx;
41             flag[bns[i]] = true;
42             cost[bns[i]] = ans[bns[i]];
43             maxx =max(maxx,ans[bns[i]]);
44             if(flag[bns[i]-1])
45             {
46                 int xx = bns[i];
47                 int yy = bns[i]-1;
48                 int x,y;
49                 for(x = xx; x!=bin[x];)
50                     x = bin[x];
51                 for(y = yy; y!=bin[y];)
52                     y = bin[y];
53                 if(du[x]>du[y])
54                 {
55                     bin[y] = x;
56                     du[x]+=du[y];
57                     cost[x]+=cost[y];
58                     maxx = max(maxx,cost[x]);
59                 }
60                 else
61                 {
62                     bin[x] = y;
63                     du[y]+=du[x];
64                     cost[y]+=cost[x];
65                     maxx = max(maxx,cost[y]);
66                 }
67             }
68                  if(flag[bns[i]+1])
69             {
70                 int xx = bns[i];
71                 int yy = bns[i]+1;
72                 int x,y;
73                 for(x = xx; x!=bin[x];)
74                     x = bin[x];
75                 for(y = yy; y!=bin[y];)
76                     y = bin[y];
77                 if(du[x]>du[y])
78                 {
79                     bin[y] = x;
80                     du[x]+=du[y];
81                     cost[x]+=cost[y];
82                     maxx = max(maxx,cost[x]);
83                 }
84                 else
85                 {
86                     bin[x] = y;
87                     du[y]+=du[x];
88                     cost[y]+=cost[x];
89                     maxx = max(maxx,cost[y]);
90                 }
91             }
92         }
93         for(i = 1;i <= n;i++)
94         {
95             printf("%lld
",ask[i]);
96         }
97     }
98     return 0;
99 }

You are given a set Y of n distinct positive integers y₁, y₂, ..., y_n.

Set X of n distinct positive integers x₁, x₂, ..., x_n is said to generate set Y if one can transform X to Y by applying some number of the following two operation to integers in X:

Take any integer x_i and multiply it by two, i.e. replace x_i with 2·x_i.
Take any integer x_i, multiply it by two and add one, i.e. replace x_i with 2·x_i + 1.

Note that integers in X are not required to be distinct after each operation.

Two sets of distinct integers X and Y are equal if they are equal as sets. In other words, if we write elements of the sets in the array in the increasing order, these arrays would be equal.

Note, that any set of integers (or its permutation) generates itself.

You are given a set Y and have to find a set X that generates Y and the maximum element of X is mininum possible.

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 50 000) — the number of elements in Y.

The second line contains n integers y₁, ..., y_n (1 ≤ y_i ≤ 10⁹), that are guaranteed to be distinct.

Output

Print n integers — set of distinct integers that generate Y and the maximum element of which is minimum possible. If there are several such sets, print any of them.

Examples

Input

5
1 2 3 4 5

Output

4 5 2 3 1

Input

6
15 14 3 13 1 12

Output

12 13 14 7 3 1

Input

6
9 7 13 17 5 11

Output

4 5 2 6 3 1 
思路:贪心;
每次选取当前数中最大的进行除2,当队列中没有的时候将新的数加入队列继续,如果存在则一直进行下去,如果得到0,那么说明当前的数已经不能分解了.复杂度（n*log（n）^2）

 1 #include<stdio.h>
 2 #include<algorithm>
 3 #include<iostream>
 4 #include<string.h>
 5 #include<queue>
 6 #include<set>
 7 #include<math.h>
 8 #include<map>
 9 using namespace std;
10 typedef long long LL;
11 int ans[50005];
12 int bns[50005];
13 typedef struct pp
14 {
15         int x;
16         bool operator<(const pp &cx)const
17         {
18                 return cx.x>x;
19         }
20 } ss;
21 priority_queue<ss>que;
22 map<int,int>my;
23 int main(void)
24 {
25         int n;
26         while(scanf("%d",&n)!=EOF)
27         {
28                 int i,j;int cn = 0;
29                 my.clear();
30                 while(!que.empty())
31                         que.pop();
32                 for(i = 0; i < n; i++)
33                 {
34                         scanf("%d",&ans[i]);
35                         ss ak;
36                         ak.x = ans[i];
37                         que.push(ak);
38                         my[ans[i]]++;
39                 }
40                 while(true&&!que.empty())
41                 {
42                         ss ak = que.top();
43                         //printf("%d
",ak.x);
44                         que.pop();
45                         int v = ak.x;
46                         my[ak.x]--;
47                         int c = ak.x/2;
48                         while(my.count(c))
49                         {
50                               c/=2;
51                         }
52                         if(c == 0)
53                         {
54                             bns[cn++] = v; break;
55                         }
56                         else
57                         {
58                             ak.x = c;
59                             que.push(ak);
60                             my[c]++;
61                         }
62                 }
63                 while(!que.empty())
64                 {
65                     bns[cn++] = que.top().x;
66                     que.pop();
67                 }
68                 printf("%d",bns[0]);
69                 for(i = 1;i < cn;i++)
70                 {
71                     printf(" %d",bns[i]);
72                 }
73                 printf("
");
74         }
75         return 0;
76 }

油！油！you@