Codeforces #Round 447Div2 D - Ralph And His Tour in Binary Country

题目链接：http://codeforces.com/contest/894/problem/D

D. Ralph And His Tour in Binary Country

time limit per test

2.5 seconds

memory limit per test

512 megabytes

input

standard input

output

standard output

Ralph is in the Binary Country. The Binary Country consists of n cities and (n - 1) bidirectional roads connecting the cities. The roads are numbered from 1 to (n - 1), the i-th road connects the city labeled (here ⌊ x⌋ denotes the x rounded down to the nearest integer) and the city labeled (i + 1), and the length of the i-th road is L_i.

Now Ralph gives you m queries. In each query he tells you some city A_i and an integer H_i. He wants to make some tours starting from this city. He can choose any city in the Binary Country (including A_i) as the terminal city for a tour. He gains happiness (H_i - L) during a tour, where L is the distance between the city A_i and the terminal city.

Ralph is interested in tours from A_i in which he can gain positive happiness. For each query, compute the sum of happiness gains for all such tours.

Ralph will never take the same tour twice or more (in one query), he will never pass the same city twice or more in one tour.

Input

The first line contains two integers n and m (1 ≤ n ≤ 10⁶, 1 ≤ m ≤ 10⁵).

(n - 1) lines follow, each line contains one integer L_i (1 ≤ L_i ≤ 10⁵), which denotes the length of the i-th road.

m lines follow, each line contains two integers A_i and H_i (1 ≤ A_i ≤ n, 0 ≤ H_i ≤ 10⁷).

Output

Print m lines, on the i-th line print one integer — the answer for the i-th query.

Examples

Input

2 2
5
1 8
2 4

Output

11
4

Input

6 4
2
1
1
3
2
2 4
1 3
3 2
1 7

Output

11
6
3
28

Note

Here is the explanation for the second sample.

Ralph's first query is to start tours from city 2 and H_i equals to 4. Here are the options:

• He can choose city 5 as his terminal city. Since the distance between city 5 and city 2 is 3, he can gain happiness 4 - 3 = 1.
• He can choose city 4 as his terminal city and gain happiness 3.
• He can choose city 1 as his terminal city and gain happiness 2.
• He can choose city 3 as his terminal city and gain happiness 1.
• Note that Ralph can choose city 2 as his terminal city and gain happiness 4.
• Ralph won't choose city 6 as his terminal city because the distance between city 6 and city 2 is 5, which leads to negative happiness for Ralph.

So the answer for the first query is 1 + 3 + 2 + 1 + 4 = 11.

题意

有n个城市，i和2i存在一条边，i和2i+1也连一条边。
给你每条边的长度。
现在给你m个询问，每个询问给你a和h，表示起点为a，然后让你求sigma(max(h-dist[i],0))

题解

对于每个节点算一下他子节点(包括他自己)到它的距离，存在dis里，同时每个节点维护一个前缀和，按照距离有序后的前缀和，空间大概是N*logN。对于每次询问，第一步当然是从他子节点里找距离他第一个大于H的节点，由于前缀和算出来了,可以O(1)算贡献。由于有完全二叉树，接着往上计算，注意加上他父亲到他，之后就是计算和他同父的另一个子树的贡献，当然h减去这2段距离(自身到父亲，父亲到兄弟)。注意预处理的时候保证有序，直接排序n*logn*logn,可以归并优化n*logn，我用了Merge合并2个有序序列，因为显然你算一个节点的时候，他两个子节点已经预处理过（有序），所以合并下就行。

#include <bits/stdc++.h>

namespace fastIO {
    #define BUF_SIZE 10000000
    //fread -> read
    bool IOerror = 0;
    inline char nc() {
        static char buf[BUF_SIZE], *p1 = buf + BUF_SIZE, *pend = buf + BUF_SIZE;
        if(p1 == pend) {
            p1 = buf;
            pend = buf + fread(buf, 1, BUF_SIZE, stdin);
            if(pend == p1) {
                IOerror = 1;
                return -1;
            }
        }
        return *p1++;
    }
    inline bool blank(char ch) {
        return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
    }
    inline void read(int &x) {
        char ch;
        while(blank(ch = nc()));
        if(IOerror)
            return;
        for(x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0');
    }
    #undef BUF_SIZE
};
using namespace fastIO;
using namespace std;
const int N = 1E6 + 7;
typedef long long ll;
vector<ll>pre[N], dis[N];
int t[N];
ll query(int s, ll h)
{
    if(h <= 0) return 0;
    int p = upper_bound(begin(dis[s]), end(dis[s]), h) - begin(dis[s]);
    return p*h - pre[s][p-1];
}
int main()
{
    int n, m;
    read(n), read(m);
    for(int i = 2;i <= n;i ++) read(t[i]);
    for(int i = n;i >= 1;i --) {
        vector<ll>tmp[2];
        tmp[0].emplace_back(0);
        for(int c = 0;c < 2;c ++) {
            int x = 2 * i + c;
            if(x > n) continue;
            for(ll it:dis[x]) {
                tmp[c].emplace_back(it + t[x]);
            }
        }
        dis[i].resize(tmp[0].size() + tmp[1].size());
        merge(begin(tmp[0]), end(tmp[0]), begin(tmp[1]), end(tmp[1]), begin(dis[i]));
        int tot = dis[i].size();
        pre[i].resize(tot);
        for(int j = 1;j < tot;j ++) pre[i][j] = pre[i][j-1] + dis[i][j];
    }
    while(m --) {
        int a, h;
        ll ans = 0;
        read(a), read(h);
        ans += query(a, h);
        while(a > 1) {
            int b = a;
            a >>= 1;
            h -= t[b];
            if(h <= 0) break;
            ans += h;
            int x = 2*a == b ? 2*a+1 : 2*a;
            if(x <= n) ans += query(x, h-t[x]);
        }
        printf("%lld\n",ans);
    }
    return 0;
}