Codeforces 226B

题目大意：
有n堆石子，告诉你它们的size，并且将其他堆的石子放进同一堆的次数不能超过给定的某一数值，问将所有的石子拼成一堆所需要的最小消耗是多少。

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.

Example
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).

思路：
首先明确以下几点：
1，大的堆合并的次数一定要尽量少，那么对于最大的堆一定是将其它的堆放到最大堆中，所以最大堆中的个数将不会计入最终的消耗中。
2，由于合并的次数有限制，但是我们容易认识到这样一个事实：
假设有n堆石子，那么将n-1堆石子直接并入最大的堆中所需要的消费最少，因为此中不存在对某一石子堆的重复计算。
所以，对于合并的次数限制，我们需要尽可能多的将次数用完。
3，这样一来加上哈弗曼树，我们就可以构造一棵（若给定次数为m，那么哈弗曼树的分支就是m）哈弗曼树来求最小值。

注意这里int会爆掉。

#include <cstdio>
#include <algorithm>
#include <memory.h>
#include <cstring>
using namespace std;
const int maxn=100050;
__int64 a[maxn];
__int64 ans[maxn];
__int64 sum[maxn];
__int64 n,q;
int cmp(__int64 a,__int64 b)
{
    return a>b;
}

int main()
{
    scanf("%I64d",&n);
    for(__int64 i=0; i<n; i++)
        scanf("%I64d",&a[i]);
    //从大到小排序
    sort(a,a+n,cmp);
    sum[0]=0;
    sum[1]=a[1];
    for(int i=2;i<n;i++)
        sum[i]=sum[i-1]+a[i];
    scanf("%I64d",&q);
   __int64 k;
    bool flag=false;
    while(q--)
    {
        if(flag) printf(" ");
        flag=true;
        scanf("%I64d",&k);
        if(ans[k])
        {
            printf("%I64d",ans[k]);
            continue;
        }
        __int64 res=0;
        __int64 cnt=k;
       __int64 top;
        __int64 val=1;
        for( __int64 i=1; i<n;)
        {
            if(cnt+i-1>n-1)
                top=n-1;
            else top=cnt+i-1;
            res+=(sum[top]-sum[i-1])*val;
            i+=cnt;
            val++;
            cnt*=k;
        }
        ans[k]=res;
        printf("%I64d",ans[k]);
    }
    return 0;
}