CodeForces - 227D Naughty Stone Piles（贪心+前缀和）

Description：

There are n piles of stones of sizes a1, a2, ..., an lying on the table in front of you.

During one move you can take one pile and add it to the other. As you add pile i to pile j, the size of pile j increases by the current size of pile i, and pile i stops existing. The cost of the adding operation equals the size of the added pile.

Your task is to determine the minimum cost at which you can gather all stones in one pile.

To add some challenge, the stone piles built up conspiracy and decided that each pile will let you add to it not more than k times (after that it can only be added to another pile).

Moreover, the piles decided to puzzle you completely and told you q variants (not necessarily distinct) of what k might equal.

Your task is to find the minimum cost for each of q variants.

Input

The first line contains integer n (1 ≤ n ≤ 105) — the number of stone piles. The second line contains n space-separated integers: a1, a2, ..., an (1 ≤ ai ≤ 109) — the initial sizes of the stone piles.

The third line contains integer q (1 ≤ q ≤ 105) — the number of queries. The last line contains q space-separated integers k1, k2, ..., kq (1 ≤ ki ≤ 105) — the values of number k for distinct queries. Note that numbers ki can repeat.

Output

Print q whitespace-separated integers — the answers to the queries in the order, in which the queries are given in the input.

Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.

Examples

Input

5
2 3 4 1 1
2
2 3

Output

9 8 

Note

In the first sample one way to get the optimal answer goes like this: we add in turns the 4-th and the 5-th piles to the 2-nd one; then we add the 1-st pile to the 3-rd one; we add the 2-nd pile to the 3-rd one. The first two operations cost 1 each; the third one costs 2, the fourth one costs 5 (the size of the 2-nd pile after the first two operations is not 3, it already is 5).

In the second sample you can add the 2-nd pile to the 3-rd one (the operations costs 3); then the 1-st one to the 3-th one (the cost is 2); then the 5-th one to the 4-th one (the costs is 1); and at last, the 4-th one to the 3-rd one (the cost is 2).

这道题唯一的难点就是要逆向思维，如果不限制每次可以拿多少几堆石子，那么答案就是石子总重量-最大堆的石子的重量，加上限制条件K以后，一个石头堆直接移动到最大石头堆中..是1次移动..若其先与其他石头堆合并一次..在同那堆石头一起加到最大石头堆中..实际相当于移动了两次...若其先先合并了k次.. 再加到最大石头堆中..那么这堆移动成功的代价是其石头数*合并数，为了使得总的代价最小..那么期望的是石头数越大的堆合并的次数越少..限制了每次合并只能拿k堆，那么当前最大的石子堆之前的石子堆必须是拿一次，就是合并最后一次。

最后再注意一下long long 就行了。

AC代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stdlib.h>
#include<stack>
#include<vector>
#include<map>
const int INF = 0x3f3f3f3f;
using namespace std;
typedef long long ll;
typedef double ld;
int i,j,k,l;
int n;
ll m,q;
int c,d;
int cnt;
int ans;
ll a[999990];
ll sum[999990];
ll minn(ll a,ll b)
{
    return a<b?a:b;
}
int main()
{
    scanf("%d",&n);
    a[0]=0;
    for(i=1;i<=n;i++)
        scanf("%lld",&a[i]);
    sort(a+1, a+n+1);
    for(i=1;i<=n;i++)
        a[i]+=a[i-1];
    for(i=1;i<=n;i++)
    {
        q=n-1;
        m=i;
        while(q>=1)
        {
            sum[i]+=a[q]; 
            q-=m;
            m*=i;
        }
    }
    /*for(i=1;i<=n;i++)
    cout<<sum[i]<<" ";
    cout<<endl;*/
    scanf("%lld",&m);
    while(m--)
    {
         scanf("%lld",&q);
         ll mine=minn(n,q);
        printf("%lld ",sum[mine]);
    }
    return 0;
}