11079 可以移动的石子合并（优先做）

题目

Description
有n堆石子形成一行(a1,a2,…,an，ai为第i堆石子个数)，现要将石子合并成一堆，规定每次可
选择至少2堆最多k堆移出然后合并，每次合并的分值为新堆的石子数。

若干次合并后，石子最后肯定被合并为一堆，得分为每次合并的分值之和。

现在求解将这n堆石子合并成一堆的最低得分和最高得分。

输入格式
两行。第一行n和k。
第二行a1 a2 … an，每个ai(1<=i<=n)表示第i堆石子的个数，n<=200，2<=k<=n。

输出格式
仅一行，为石子合并的最低得分和最高得分，中间空格相连。

输入样例
7 3
45 13 12 16 9 5 22

输出样例
199 593

提示

此题贪心算法求解.
给这题标记标签"dp"方法是同学所为,并非老师标注.动规不是不可以,但有更好更快的贪心解法的.

如7堆石头，每次可选择最少2堆最多3堆合并，可以如下这样合并：
第1次合并：45+22=67
第2次合并：67+16=83
第3次合并：83+13=96
第4次合并：96+12=108
第5次合并：108+9=117
第6次合并：117+5=122
合并的总分值：67+83+96+108+117+122=593，593已是最大分值。

也可以这样合并：
第1次合并：5+9+12=26
第2次合并：13+16+22=51
第3次合并：45+51+26=122
合并的总分值：26+51+122=199，199已是最小分值。

因此此题贪心的方法如下：

（1）保证每次选两堆最多的，合并直至只剩一堆为止，能获得最大得分；
这个和huffman树构造是相同的，不再详述！

（2）保证每次选k堆最少的，合并直至只剩一堆为止，能获得最小得分。
这个是多元huffman树的构造。要注意的是：在合并之前，若n%(k-1)!=1，说明合并到最后一轮时，
剩下不是k堆（而是比k堆少），这样算的并不是最小得分，而必须在合并之前添加若干个为0的虚拟
堆，目的为凑成的堆数保证每次都能有k堆合并（包括最后一次）最后合并为1堆。

因此，在合并前作如下处理：

//假设石头每堆个数放于stone[1]~stone[n],且stone[n]之后最多k-1个数组单元为可写;

while (n % (k - 1) != 1)
{
        n++;
        stone[n]=0;
}

思路

思路：
求最低分值：
每次都合并k堆,并且每次合并都从小到大选取石子
求最小值需要注意的问题：每次合并k堆，会产生1堆新的石子，因此石子每次减少k-1堆，
如果(k-1) * a + 1 == n,那么刚好合并a次，最后一次合并刚好够k堆，合并完成后剩下1堆
如果n % (k-1) != 1或者(n-1) % (k-1) != 0，则最后一次不是能刚好合并k堆，那么一开始可以填充至最后一次刚好可以合并k堆，
因为填充和不填充的区别在于，同样是合并x次，与不填充0的相比，可能会导致较大石子提前被合并
求最高分值：
每次只合并2堆，这样可以合并最多次，每次合并最大的石子即可

贪心+小根堆

#include <iostream>
#include <algorithm>

using namespace std;

// 思路：
// 求最低分值：
//   每次都合并k堆,并且每次合并都从小到大选取石子
//   求最小值需要注意的问题：每次合并k堆，会产生1堆新的石子，因此石子每次减少k-1堆，
//   如果(k-1) * a + 1 == n,那么刚好合并a次，最后一次合并刚好够k堆，合并完成后剩下1堆
//   如果(n % (k-1) != 1)或者(n-1) % (k-1) != 0，则最后一次不是能刚好合并k堆，那么一开始可以填充至最后一次刚好可以合并k堆，
//   因为填充和不填充的区别在于，同样是合并x次，与不填充0的相比，可能会导致较大石子提前被合并
// 求最高分值：
//   每次只合并2堆，这样可以合并最多次，每次合并最大的石子即可

int a[210] = {}, b[210] = {};
int n, k;

// 小根堆
void down(int u){
    int t = u;
    if(2*u < n && b[2*u] < b[t]) t = 2*u;
    if(2*u+1 < n && b[2*u+1] < b[t]) t = 2*u+1;
    if(t != u){
        swap(b[t], b[u]);
        down(t);
    }
}
// 小根堆
void up(int u){
    while(u/2 && b[u/2] > b[u]){
        swap(b[u/2], b[u]);
        u /= 2;
    }
}

int main()
{
    cin >> n >> k;

    for(int i = 0; i < n; i++){
         cin >> a[i];
         b[i] = a[i];
    }
    int Max = 0;
    sort(a,a+n,greater<int>());//降序排序
    for(int i = 1; i < n; i++){//从第2堆开始合并，每次合并两堆
        a[i] += a[i-1];//合并两堆,合并的新堆一定还是最大的，所以不用重新调整位置
        Max += a[i];//累加新产生的1堆
    }


//   求最低得分
    int Min = 0;
//  填充0的石头，使得最后一次合并刚好够合并k堆
    while(n % (k - 1) != 1) b[n++]=0;
//  堆排序，小根堆
    for(int i = n/2; i >= 0; i--) down(i);

    int time = (n-1) / (k-1);//计算合并次数，每次都能合并k堆，因此每次减少k-1堆，最后剩下1堆
    //合并time次
    while(time --){
        int cnt = k;//合并k堆
        int newNum = 0;
        while(cnt --){
            newNum += b[0];//累加最小的石子
            b[0] = b[--n];//把堆尾的元素放到堆顶，并且元素个数-1
            down(0);//调整堆
        }
        Min += newNum;//累加每次合并的结果
        b[n++] = newNum;//把新元素放入堆中
        up(n-1);//调整堆
    }
    cout << Min << ' ' << Max << endl;
    return 0;
}