合并果子 洛谷1090

[NOIP2004 提高组] 合并果子 / [USACO06NOV] Fence Repair G - 洛谷

描述

在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。因为还要花大力气把这些果子搬回家，所以多多在合并果子时要尽可能地节省体力。假定每个果子重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使多多耗费的体力最少，并输出这个最小的体力耗费值。例如有3种果子，数目依次为1，2，9。可以先将1、2堆合并，新堆数目为3，耗费体力为3。接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为12。所以多多总共耗费体力=3+12=15。可以证明15为最小的体力耗费值。

格式

输入格式

输入包括两行，第一行是一个整数n(1<＝n<=10000)，表示果子的种类数。第二行包含n个整数，用空格分隔，第i个整数ai(1<＝ai<=20000)是第i种果子的数目。

输出格式

输出包括一行，这一行只包含一个整数，也就是最小的体力耗费值。输入数据保证这个值小于2^31。

样例1

样例输入1

3
1 2 9

Copy

样例输出1

15

Copy

限制

每个测试点1s

---

赫夫曼树

"D:\北京交通大学\01学业\大二上\数据结构\ppt\6.树和二叉树\6.4.1赫夫曼树的逻辑结构.pptx”

没看视频前的第一想法是，直接数组排序，从小到大＋。太单纯了。。。

贪心策略：每次选择最小的两个数相加，和构造哈夫曼树的策略是一样的。因为要让权值最大的元素被加的次数最少。

至于实现呢，我是跟着视频用的插入排序，每次把头两个元素相加后做一次插排。

用sum保存相加后的值，require记录总需求。

很使用的技巧是 while(true){ if() break;},比while+条件好做得多。

我的代码：

#include<iostream>
#include<algorithm>
using namespace std;
//哈夫曼树
int main(){
    int n,a[100005];
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>a[i];
    sort(a,a+n);
    long require=0,sum=a[0];
    for(int i=1;i<n;i++){
        a[i]+=a[i-1];
        sum=a[i];int j=i+1;
        //插入排序
        while(true){         
            if(j==n||a[i]<=a[j])
                break;
            j++;
        }
        for(int k=i;k<j;k++)
            a[k]=a[k+1];
        a[j-1]=sum;
        require+=sum;
    }
    cout<<require;
}

---

优先队列（priority_queue）

• #include <queue>

• priority_queue <Type, Container, Functional>

  元素类型/容器类型/比较方式。

• 特点：最高优先级的元素先出。

• 操作：

  top 访问队头元素 empty 队列是否为空 size 返回队列内元素个数 push 插入元素到队尾 (并排序) emplace 原地构造一个元素并插入队列 pop 弹出队头元素 swap 交换内容

• 比较方式：

  • 大顶堆（大的优先级高）

    默认/less<int>

  • 小顶堆

    greater<int>

  • 自定义

    • 重载（)

    struct cmp(){
    	bool operator()(Node* a, Node* b){
    			return a.val > b.val;
    	}
    };
    	priority_queue<Node*, vector<Node*>, cmp> q;
    

    • 重载运算符

    struct Status{
    	int val;
    	Node* node;
    	bool operator < (const Status &tmp) const{
    		// 函数必须是静态的 使得该函数可以被 const 对象也就是常量所调用
        // 形参可以加上const关键字和&，保证安全性，提高效率
    			return val>tmp.val;
    	}
    };
    priority_queue<Status> q;
    

    • 利用友元函数重载<

    struct Status{
    	int val;
    	Node* node;
    	friend bool operator < (Status a,Status b){
    		return a.val > b.val;
    	}
    };
    priority_queue<Status> q;
    

#include<iostream>
#include<queue>
using namespace std;

int main(){
    int n,temp;
    long require=0,sum=0;
    priority_queue<int,vector<int>,greater<int>> a;
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>temp;
        a.push(temp);
    }
    for(int i=0; i<n-1; i++){
        sum=a.top();
        a.pop();
        sum+=a.top();
        a.pop();
        a.push(sum);
        require+=sum;
    }
    cout<<require;
}