Intel Code Challenge Elimination Round (Div.1 + Div.2, combined) C. Destroying Array -- 逆向思维

　　原题中需要求解的是按照它给定的操作次序，即每次删掉一个数字求删掉后每个区间段的和的最大值是多少。

　　正面求解需要维护新形成的区间段，以及每段和，需要一些数据结构比如 map 和 set。 map<int, LL>interval2Sum来维护区间段（u->v），mulitset<LL>sum 来维护最大值。那么每次删除操作后，都需要去interval2Sum中找到对应区间，然后erase掉，

重新生成left -> delId -> right两个区间段，最后在maxSum中删掉原有的sum值 ,加入新形成的两短sum。正面刚的话，因为map 和 set的高效性 log级别所以速度还是不错的。（代码转自Codeforces : Ra16bit）

　　

#include <bits/stdc++.h>
using namespace std;
int n,i,a,le,ri;
long long s[];
map<int, long long> all;
multiset<long long> sum;
int main() {
  scanf("%d",&n);
  for (i=; i<=n; i++) {
    scanf("%d",&a);
    s[i]=s[i-]+a;
  }
  all[]=n;
  sum.insert(-s[n]);
  for (i=; i<=n; i++) {
    scanf("%d",&a);
    auto it=all.lower_bound(a);
    it--;
    le=it->first;
    ri=it->second;
    sum.erase(sum.find(s[le]-s[ri]));
    all.erase(it);
    if (le+<a) {
      all[le]=a-;
      sum.insert(s[le]-s[a-]);
    }
    if (a<ri) {
      all[a]=ri;
      sum.insert(s[a]-s[ri]);
    }
    if (i==n) puts(""); else printf("%I64d\n",-*sum.begin());
  }
  return ;
}

　　反向思路，从删掉了最后一个元素开始。一个个恢复。判断左右是否有已经恢复的元素然后在区间内归并元素，用并查集来判断区间所属。那么区间段值不断增大，最后得到结果。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#define LL long long
using namespace std;

const int Maxn = ;
int n, delId[Maxn], par[Maxn], used[Maxn];
LL a[Maxn], b[Maxn], ans[Maxn];

int find(int x)
{
    return (par[x] == x)?x: find(par[x]);
}

int main()
{
    cin>>n;
    for(int i = ; i < n; i ++){
        scanf("%lld",&a[i]);
        par[i] = i;
        used[i] = ;
    }for(int i = ; i < n; i ++){
        scanf("%d",&delId[i]);
        delId[i] --;
    }
    for(int i = n - ; i >= ; i --){
        int index = delId[i];
        used[index] = ;
        b[index] += a[index];
        if(used[index - ] && index){
            int fa = find(index - );
            b[fa] += a[index];
            par[index] = fa;
        }if(used[index + ] && index != n - ){
            int newFa = find(index), oldFa = find(index + );
            par[oldFa] = newFa;
            b[newFa] += b[oldFa];
        }
        ans[i] = max(ans[i + ], b[find(index)]);
    }
    for(int i = ; i <= n; i ++){
        cout<<ans[i]<<" ";
    }cout<<endl;
    return ;
}

C. Destroying Array

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

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.

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 a1, a2, ..., an (0 ≤ ai ≤ 109).

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

5
4
3
0

input

5
1 2 3 4 5
4 2 3 5 1

output

6
5
5
1
0

input

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

output

18
16
11
8
8
6
6
0

Note

Consider the first sample:

1. Third element is destroyed. Array is now 1 3  *  5. Segment with maximum sum 5 consists of one integer 5.
2. Fourth element is destroyed. Array is now 1 3  *   * . Segment with maximum sum 4 consists of two integers 1 3.
3. First element is destroyed. Array is now  *  3  *   * . Segment with maximum sum 3 consists of one integer 3.
4. Last element is destroyed. At this moment there are no valid nonempty segments left in this array, so the answer is equal to 0.