POJ 3253 Fence Repair (priority_queue的用法) ----- less<int> 和 greater<int>

大致题意：

有一个农夫要把一个木板钜成几块给定长度的小木板，每次锯都要收取一定费用，这个费用就是当前锯的这个木版的长度

给定各个要求的小木板的长度，及小木板的个数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的比较规则的返回值的意义刚好相反

 

附：

Source修正：

本题测试数据http://ace.delos.com/TESTDATA/NOV06_4.htm

从测试数据看得到是存在大数的情况的，要使用 __int64

 

 

[cpp] view plaincopy
  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. }  


 

===========华丽的分割线==============

 

[cpp] view plaincopy
  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. }  


 

 

===========华丽的分割线==============

 

[cpp] view plaincopy
  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. }  
posted on 2012-03-07 17:20  万里心晴  阅读(718)  评论(0)  编辑  收藏  举报

Powered by: 博客园 Copyright © 2024 万里心晴
Powered by .NET 8.0 on Kubernetes