POJ3253-Fence Repair
转载请注明出处:優YoU http://user.qzone.qq.com/289065406/blog/1304489412
大致题意:
有一个农夫要把一个木板钜成几块给定长度的小木板,每次锯都要收取一定费用,这个费用就是当前锯的这个木版的长度
给定各个要求的小木板的长度,及小木板的个数n,求最小费用
提示:
以
3
5 8 5为例:
先从无限长的木板上锯下长度为 21 的木板,花费 21
再从长度为21的木板上锯下长度为5的木板,花费5
再从长度为16的木板上锯下 长度为8的木板,花费8
总花费 = 21+5+8 =34
解题思路:
利用Huffman思想,要使总费用最小,那么每次只选取最小长度的两块木板相加,再把这些“和”累加到总费用中即可
本题虽然利用了Huffman思想,但是直接用HuffmanTree做会超时,可以用优先队列做
因为朴素的HuffmanTree思想是:
(1)先把输入的所有元素升序排序,再选取最小的两个元素,把他们的和值累加到总费用
(2)把这两个最小元素出队,他们的和值入队,重新排列所有元素,重复(1),直至队列中元素个数<=1,则累计的费用就是最小费用
HuffmanTree超时的原因是每次都要重新排序,极度浪费时间,即使是用快排。
一个优化的处理是:
(1)只在输入全部数据后,进行一次升序排序 (以后不再排序)
(2)队列指针p指向队列第1个元素,然后取出队首的前2个元素,把他们的和值累计到总费用,再把和值sum作为一个新元素插入到队列适当的位置
由于原队首的前2个元素已被取出,因此这两个位置被废弃,我们可以在插入操作时,利用后一个元素位置,先把队列指针p+1,使他指向第2个废弃元素的位置,然后把sum从第3个位置开始向后逐一与各个元素比较,若大于该元素,则该元素前移一位,否则sum插入当前正在比较元素(队列中大于等于sum的第一个元素)的前一个位置
(3)以当前p的位置作为新队列的队首,重复上述操作
另一种处理方法是利用STL的优先队列,priority_queue,非常方便简单高效,虽然priority_queue的基本理论思想还是上述的 优化思想 ,但是STL可以直接用相关的功能函数实现这些操作,相对简单,详细参见我的程序。
注意priority_queue与qsort的比较规则的返回值的意义刚好相反
附:
本题测试数据http://ace.delos.com/TESTDATA/NOV06_4.htm
从测试数据看得到是存在大数的情况的,要使用 __int64
1 /*优先队列*/
2
3 //Memory Time
4 //376K 516MS
5
6 #include<iostream>
7 using namespace std;
8
9 int cmp(const void* a,const void* b)
10 {
11 return *(int*)a-*(int*)b;
12 }
13
14 int main(void)
15 {
16 int n;
17 while(cin>>n)
18 {
19 __int64 * w=new __int64[n+1]; //每块木板的价值
20
21 for(int p=1;p<=n;p++)
22 scanf("%I64d",&w[p]);
23
24 qsort(w,n+1,sizeof(__int64),cmp);
25
26 __int64 mincost=0;
27 for(int i=1;i<=n-1;i++) //每次枚举余下数列的前2个(最小)的元素,则i到n-1即可
28 {
29 __int64 sum=w[i]+w[i+1]; //此时w[i]和w[i+1]已经没有用了
30 mincost+=sum;
31
32 for(int j=i+2;j<=n;j++) //寻找w[i]+w[i+1]即sum在余下数列的合适位置,并插入
33 {
34 if(sum>w[j]) //sum大于当前元素
35 {
36 w[j-1]=w[j]; //当前元素前移一格
37 if(j==n) //sum大于最后的元素(即大于所有元素)
38 {
39 w[j]=sum; //插入到最后
40 break;
41 }
42 }
43 else
44 {
45 w[j-1]=sum; //插入到比sum大的第一个元素前面(此前的元素均被前移)
46 break;
47 }
48 }
49 }
50
51 printf("%I64d\n",mincost);
52 }
53 return 0;
54 }
===========华丽的分割线==============
1 /*STL 优先队列*/
2
3 //Memory Time
4 //512K 47MS
5
6 #include<iostream>
7 #include<vector>
8 #include<queue>
9 using namespace std;
10
11 //比较规则,最小优先
12 class cmp
13 {
14 public:
15 bool operator()(const __int64 a,const __int64 b)const
16 {
17 return a>b;
18 }
19 };
20
21 int main(void)
22 {
23 int n; //需要切割的木板个数
24 while(cin>>n)
25 {
26 priority_queue<__int64,vector<__int64>,cmp>Queue; //定义优先队列
27
28 for(int i=1;i<=n;i++)
29 {
30 __int64 temp;
31 scanf("%I64d",&temp);
32 Queue.push(temp); //输入要求的木板长度(费用)并入队
33 }
34
35 __int64 mincost=0; //最小费用
36 while(Queue.size()>1) //当队列中小于等于一个元素时跳出
37 {
38 __int64 a=Queue.top(); //得到队首元素的值,并使其出队
39 Queue.pop();
40 __int64 b=Queue.top(); //两次取队首,即得到最小的两个值
41 Queue.pop();
42
43 Queue.push(a+b); //入队
44 mincost+=a+b;
45 }
46
47 printf("%I64d\n",mincost);
48
49 while(!Queue.empty()) //清空队列
50 Queue.pop();
51 }
52 return 0;
53 }
===========华丽的分割线==============
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 /*朴素思想 --->> TLE*/
2
3 #include<iostream>
4 using namespace std;
5
6 const __int64 inf=1e18;
7
8 int cmp(const void* a,const void* b)
9 {
10 return *(int*)a-*(int*)b;
11 }
12
13 int main(int p)
14 {
15 int n;
16 while(cin>>n)
17 {
18 __int64* w=new __int64[2*n]; //每块木板的价值
19
20 for(int i=0;i<2*n;i++)
21 w[i]=inf;
22
23 for(p=0;p<n;p++)
24 scanf("%I64d",&w[p]);
25
26 int mincost=0;
27 while(true)
28 {
29 qsort(w,2*n,sizeof(__int64),cmp);
30
31 if(w[1]==inf)
32 break;
33
34 w[p]=w[0]+w[1];
35 w[0]=w[1]=inf;
36 mincost+=w[p++];
37 }
38
39 cout<<mincost<<endl;
40
41 delete w;
42 }
43 return 0;
44 }