11079 可以移动的石子合并（贪心）

11079 可以移动的石子合并

时间限制:1000MS  内存限制:1000K
提交次数:0 通过次数:0 

题型: 编程题   语言: C++;C;VC;JAVA

Description

有n堆石子形成一行(a1,a2,…,an，ai为第i堆石子个数)，现要将石子合并成一堆，规定每次可选择至少2堆最多k堆移出然后合并，每次合并的分值为新堆的石子数。
若干次合并后，石子最后肯定被合并为一堆，得分为每次合并的分值之和。
现在求解将这n堆石子合并成一堆的最低得分和最高得分。

输入格式

两行。第一行n和k，第二行a1 a2 … an，每个ai(1<=i<=n)表示第i堆石子的个数，n<=100，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;
}

作者

zhengchan

我的实现代码：

其中sort()用插入排序替换更佳

#include <iostream>
#include <algorithm>

using namespace std;
/*
测试数据：
 
7 3
45 13 12 16 9 5 22

6 3
1 2 3 4 5 6

*/

int main()
{
    int n,k;
    cin >> n >> k;
    
    int stone[n+10];
    
    for (int i = 0; i < n; i++) {
        cin >> stone[i];
    }
    
    int cur;
    int minC = 0,maxC = 0;
    int minTemp, maxTemp;
    
    sort(stone, stone + n);
    
    cur = n-1;
    maxTemp = stone[cur];
    while (cur != 0) {// 求最大
        maxTemp = maxTemp + stone[cur - 1];
        maxC += maxTemp;
        cur--;
    }
    
//  ========================================================================
    
    
    //假设石头每堆个数放于stone[1]~stone[n],且stone[n]之后最多k-1个数组单元为可写;
    while (n % (k - 1) != 1) {
        stone[n++] = 0;
    }
    
    sort(stone, stone + n);
    
    cur = 0;
    minTemp = stone[cur];
    while (cur <= n - k) {// 求最小
        
        for (int i = 0; i < k - 1; i++) {
            stone[cur + k-1] += stone[cur + i];
        }
        minC += stone[cur + k-1];
        cur += k-1;
        
        sort(stone, stone + n);
//        for (int i = 0; i < n; i++) {
//            cout << stone[i] << " ";
//        }
//        cout << endl;
    }
    
    cout << minC << " " << maxC;
    
    cout << endl;
    return 0;
}

以上代码太烂，也不删了，当作过程记录

使用“堆”辅助，代码更新如下：

#include <iostream>
#include <queue>
#include <algorithm>

using namespace std;
/*
 测试数据：

7 3
45 13 12 16 9 5 22

6 3
1 2 3 4 5 6

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

 */

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

    priority_queue<int> maxHeap;// 大顶堆
    priority_queue<int, vector<int>, greater<int> > minHeap;// 小顶堆

    int temp;// 记录输入值
    for (int i = 0; i < n; i++) {
        cin >> temp;
        maxHeap.push(temp);// 入大顶堆
        minHeap.push(temp);// 入小顶堆
    }

    int maxCount = 0;// 记录最高得分
    while (maxHeap.size() != 1) {// 只剩1堆，合并完成

        // 求最高得分，则每次取分值最高的2堆合并
        int maxT = maxHeap.top();
        maxHeap.pop();
        maxT += maxHeap.top();
        maxHeap.pop();

        maxHeap.push(maxT);// 合并所得，入大顶堆
        maxCount += maxT;// 统计最高得分
    }

    while (n % (k - 1) != 1) {// 保证最后一次合并时有k堆石子，否则结果错误！
        minHeap.push(0);
        n++;// n相应变大
    }

    int minCount = 0;// 记录最低得分
    while (minHeap.size() != 1) {// 只剩1堆，合并完成

        // 求最低得分，则每次取分值最低的k堆合并
        int minT = 0;
        for(int i = 0; i < k; i++){
            minT += minHeap.top();
            minHeap.pop();
        }

        minHeap.push(minT);// 合并所得，入小顶堆
        minCount += minT;// 统计最低得分
    }

    cout << minCount << " " << maxCount << endl;
    return 0;
}