Poj3253--Fence Repair、、南阳55--省懒事的小明（哈夫曼树）

懒省事的小明

时间限制：3000 ms  |  内存限制：65535 KB

难度：3

 

描述

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

 

输入

第一行输入整数N(0<N<=10)表示测试数据组数。接下来每组测试数据输入包括两行，第一行是一个整数n(1<＝n<=12000)，表示果子的种类数。第二行包含n个整数，用空格分隔，第i个整数ai(1<＝ai<=20000)是第i种果子的数目。

输出

每组测试数据输出包括一行，这一行只包含一个整数，也就是最小的体力耗费值。

样例输入

1
3 
1 2 9

样例输出

15

来源

[hzyqazasdf]原创

上传者

hzyqazasdf

//数组实现优先队列；

#include <stdio.h>
#include <algorithm>
using namespace std;
long long int num[12020];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int i, j, m;
        scanf("%d", &m);
        for(i=0; i<m; i++)
        scanf("%lld", &num[i]);
        sort(num, num+m);
        long long int total = 0;
        for(i=0; i<m; i++)
        {
            if(i == m-1)
            break;
            long long int temp = num[i]+num[i+1];
            num[i+1] = temp;
            total += temp;
            for(j=i+1; j < m; j++)
            {
                if(num[j] < num[j-1])
                {
                    long long int s;
                    s = num[j]; num[j] = num[j-1]; num[j-1]=s;                    
                }
            }
        }
        printf("%lld
",total);
    }
    return 0;
}

//STL;

#include <queue>
#include <cstdio>
#include <iostream>
using namespace std;
int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        priority_queue<int, vector<int>, greater<int> >q;
        int i, m;
        scanf("%d", &m);
        for(i=0; i<m; i++)
        {
            int num;
            scanf("%d", &num);
            q.push(num);        
        }
        long long int total = 0;
        while(q.size()!=1)
        {
            long long int temp = q.top();
            q.pop();
            temp += q.top();
            q.pop();
            q.push(temp);
            total += temp;        
        }
        printf("%lld
",total);
    }
    return 0;
}

Fence Repair

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 32357		Accepted: 10397

Description

Farmer John wants to repair a small length of the fence around the pasture. He measures the fence and finds that he needs N (1 ≤ N ≤ 20,000) planks of wood, each having some integer length L_i(1 ≤ L_i ≤ 50,000) units. He then purchases a single long board just long enough to saw into the N planks (i.e., whose length is the sum of the lengths L_i). FJ is ignoring the "kerf", the extra length lost to sawdust when a sawcut is made; you should ignore it, too.

FJ sadly realizes that he doesn't own a saw with which to cut the wood, so he mosies over to Farmer Don's Farm with this long board and politely asks if he may borrow a saw.

Farmer Don, a closet capitalist, doesn't lend FJ a saw but instead offers to charge Farmer John for each of the N-1 cuts in the plank. The charge to cut a piece of wood is exactly equal to its length. Cutting a plank of length 21 costs 21 cents.

Farmer Don then lets Farmer John decide the order and locations to cut the plank. Help Farmer John determine the minimum amount of money he can spend to create the N planks. FJ knows that he can cut the board in various different orders which will result in different charges since the resulting intermediate planks are of different lengths.

Input

Line 1: One integer N, the number of planks 
Lines 2..N+1: Each line contains a single integer describing the length of a needed plank

Output

Line 1: One integer: the minimum amount of money he must spend to make N-1 cuts

Sample Input

3
8
5
8

Sample Output

34

Hint

He wants to cut a board of length 21 into pieces of lengths 8, 5, and 8. 
The original board measures 8+5+8=21. The first cut will cost 21, and should be used to cut the board into pieces measuring 13 and 8. The second cut will cost 13, and should be used to cut the 13 into 8 and 5. This would cost 21+13=34. If the 21 was cut into 16 and 5 instead, the second cut would cost 16 for a total of 37 (which is more than 34).

Source

USACO 2006 November Gold

#include <queue>
#include <cstdio>
#include <iostream>
using namespace std;
int main()
{
    int t, m;
    while(~scanf("%d", &t))
    {
        priority_queue <int, vector<int>, greater<int> >q;
        while(t--)
        {
            scanf("%d", &m);
            q.push(m);
        } 
        __int64 total = 0;
        while(q.size() != 1)
        {
            __int64 temp = q.top();
            q.pop();
            temp += q.top();
            q.pop();
            q.push(temp);
            total += temp;
        //    printf("%d
",temp);
        }
        printf("%I64d
", total);
    }
    return 0;
}