POJ 3253

分析

可以用的算法，首先想到的是贪心，再想一想可以理解成哈夫曼编码
因为每次砍掉的成本包含着等待被砍掉的长度。所以我们可以试想一下，如果你是伐木工，要想让成本最小，你会选择先砍短的长度还是先砍长的长度？
当然是先砍大的部分，因为把小的留到最后砍，假设最小的是2，那么我砍10次，2的成本是10*2，但是如果我把最长的10留到最后砍，同样砍10次，那么成本就是10*10，因此我们选择先砍长的长度

采用哈夫曼编码的思想，我们把越长的排在越前面，最短的长度作为叶子节点，这样我们就可以保证成本一定最小。

这道题不需要我们构造一棵完整的哈夫曼树，我们只需要模仿哈夫曼树的构建过程，然后计算出代价即可。

使用次数最多那么编码应该最短，因此我们要让权重越高的数据编码越短，而我们这里的长度刚好等于代价即权重，因此在模仿构造哈夫曼树的时候，我们么可以借助STL中的优先队列priority_queue<>

图片出处见原图水印(不是本人制作)

详细使用方法可以参考优先队列的详细使用方法

每次出队两个最小值，加和后再放入队列，直到队列的size==1，输出最后值即可。

采用优先队列解决问题

//借用优先队列模仿哈夫曼
//注意要考虑当n==1时的情况
#include<iostream>
#include<queue>
#include<algorithm>
#include<vector>
#include<functional>

using namespace std;

int main(){
    int n;
    int l[20001];
    cin >> n;
    int ans=0;//记录木材总长度
    priority_queue<int,vector<int>,greater<int>> q;
    for(int ix=0;ix<n;++ix){
        int x;
        cin >> x;
        q.push(x);
    }
    if(n==1){
    	cout << q.top() << endl;
    }
    int sum=0;//记录总代价
    while(q.size()!=1){
        int min1,min2;
        min1=q.top();q.pop();
        min2=q.top();q.pop();
        int t=min1+min2;
        sum+=t;
        q.push(t);
    }
    cout << sum << endl;
    return 0;  

}

作者的代码

#include<iostream>
#include<algorithm>

using namespace std;

typedef long long ll;
const int MAX_N=20000;
int N,L[MAX_N+1];

void solve();


int main(){
    cin >> N;
    for(int i=0;i<N;++i){
        cin >> L[i];
    }
    solve();
    return 0;
}

void solve(){
    ll ans=0;//记录代价
    //直到计算到木板为1块时为止

    while(N>1){
        //求出最短的板min1和次短的板min2
        int min1=0,min2=1;//记录这两块板的坐标
        if(L[min1]>L[min2]){//确保min1<min2，min1记录的一定是最短的板
            swap(min1,min2);
        }

        for(int i=2;i<N;++i){//找到最短和次短的板的坐标//!注意这里，N的值在变的，有点冒泡的味道
            if(L[i]<L[min1]){
                min2=min1;
                min1=i;
            }else if(L[i]<L[min2]){
                min2=i;
            }
        }

        int t=L[min1]+L[min2];//记录当前的代价
        
        ans+=t;//总代价
        if(min1==N-1){//如果最短板的坐标是当前查找范围的最后一位，就和次短的板交换位置(仅坐标)
            swap(min1,min2);
        }
        L[min1]=t;//让最短的板成为代价板，相当于哈夫曼编码中的两个叶子节点的父节点
        L[min2]=L[N-1];//将N-1位置的板的长度放到min2位置，因为接下来N--，N位置的长度不在搜索范围内了
        N--;
    }
    cout << ans << endl;
}

模仿哈夫曼编码的方法（作者的思想，但是我写的会超时，可能是因为sort的关系，而且我的变量sum没有申明为long long int 会造成越界）

#include<iostream>
#include<algorithm>

using namespace std;

int main(){
    int n;
    cin >> n;
    int l[20010];
    for(int i=0;i<n;++i){
        cin >> l[i];
    }
    int cnt=0;
    int sum=0;
    //我们用n来代替i
    while(n>1){//最后一个留在里面的是总长度，在合成最后一个根节点的时候是不需要算进去的
        sort(l,l+n);
        int m1,m2;
        m1=l[0],m2=l[1];
        int t=m1+m2;
        sum+=t;
        l[0]=t;l[1]=l[n-1];
        n--;
    }
    cout << sum << endl;
    return 0;
}

AC截图