You are given an array consisting of n non-negative integers a1, a2, ..., an.
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.
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 a1, a2, ..., an (0 ≤ ai ≤ 109).
The third line contains a permutation of integers from 1 to n — the order used to destroy elements.
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.
4
1 3 2 5
3 4 1 2
5
4
3
0
5
1 2 3 4 5
4 2 3 5 1
6
5
5
1
0
8
5 5 4 4 6 6 5 5
5 2 8 7 1 3 4 6
18
16
11
8
8
6
6
0
思路：并查集；
倒着来做，每次我们向原来的序列中加点，那么我们如果知道他的左边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 y1, y2, ..., yn.
Set X of n distinct positive integers x1, x2, ..., xn 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 xi and multiply it by two, i.e. replace xi with 2·xi.
- Take any integer xi, multiply it by two and add one, i.e. replace xi with 2·xi + 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.
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 y1, ..., yn (1 ≤ yi ≤ 109), that are guaranteed to be distinct.
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.
5
1 2 3 4 5
4 5 2 3 1
6
15 14 3 13 1 12
12 13 14 7 3 1
6
9 7 13 17 5 11
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 }