贪心(哈夫曼树):HDU 5884 sort

  这道题目,我做的时候不会哈夫曼树,自己贪心是错的都不知晓。还可以发现这里不必用优先队列,可以用两个队列,毕竟插入的数是有单调性的。

 1 #include <algorithm>
 2 #include <iostream>
 3 #include <cstring>
 4 #include <cstdio>
 5 using namespace std;
 6 const int N=300010;
 7 int a[N],n,S,f1,f2,b1,b2;
 8 int q1[N],q2[N];
 9 bool Check(int k){
10     f1=b1=f2=b2=0;
11     for(int i=1;i<=n;i++)
12         q1[b1++]=a[i];
13     for(int i=0;(n+i-1)%(k-1);i++)
14         q2[b2++]=0;
15     int tot=0,tmp;
16     while(true){tmp=0;
17         for(int i=1;i<=k;i++){
18             if(f1==b1)tmp+=q2[f2++];
19             else if(f2==b2)tmp+=q1[f1++];
20             else if(q1[f1]<q2[f2])tmp+=q1[f1++];
21             else tmp+=q2[f2++];
22         }tot+=tmp;
23         if(f1>=b1&&f2>=b2)break;
24         q2[b2++]=tmp;
25     }
26     return tot<=S;
27 }
28 int main(){
29     int T;
30     scanf("%d",&T);
31     while(T--){
32         scanf("%d%d",&n,&S);
33         for(int i=1;i<=n;i++){
34             scanf("%d",&a[i]);
35         }
36         sort(a+1,a+n+1);
37         int lo=2,hi=n;
38         while(lo<=hi){
39             int mid=(lo+hi)>>1;
40             if(Check(mid))hi=mid-1;
41             else lo=mid+1;
42         }
43         printf("%d\n",lo);
44     }
45     return 0;
46 }
时间: 2024-08-18 03:32:42

贪心(哈夫曼树):HDU 5884 sort的相关文章

两个队列+k叉哈夫曼树 HDU 5884

1 // 两个队列+k叉哈夫曼树 HDU 5884 2 // camp题解: 3 // 题意:nn个有序序列的归并排序.每次可以选择不超过kk个序列进行合并,合并代价为这些序列的长度和.总的合并代价不能超过TT, 问kk最小是多少. 4 // . 5 // 题解:首先二分一下这个kk.然后在给定kk的情况下,这个代价其实就是kk叉的哈夫曼树问题.因此直接套用哈夫曼树的堆做法即可.复杂度O(nlog^2n) 6 // ?,这样优化一下读入是可以卡过去的. 7 // 然后主代码手表示,利用合并的单调

哈夫曼树——贪心

哈夫曼树——贪心 哈夫曼树:给定n个权值作为n的叶子结点,构造一棵二叉树,若带权路径长度达到最小,称这样的二叉树为最优二叉树,也称为哈夫曼树(Huffman tree).哈夫曼树是带权路径长度                 最短的树,权值较大的结点离根较近. 此类题目一般求算哈夫曼树路径总值,利用贪心选择性质每次从队头取出两个边权和最小的树合并成新树入队(优先队列,保证队首元素最小),每次记录新树权值,当队内只剩一棵树时结束算法: priority_queue<long long,vector

HDU 5884 Sort (二分+k叉哈夫曼树)

题意:n 个有序序列的归并排序.每次可以选择不超过 k 个序列进行合并,合并代价为这些序列的长度和.总的合并代价不能超过T, 问 k最小是多少. 析:首先二分一下这个 k .然后在给定 k 的情况下,这个代价其实就是 k 叉的哈夫曼树问题.然后用两个队列维护一下就好. 代码如下: #pragma comment(linker, "/STACK:1024000000,1024000000") #include <cstdio> #include <string>

hdu5884 Sort(二分+k叉哈夫曼树)

题目链接:hdu5884 Sort 题意:n个有序序列的归并排序.每次可以选择不超过k个序列进行合并,合并代价为这些序列的长度和.总的合并代价不能超过T, 问k最小是多少. 题解:先二分k,然后在k给定的情况下,构造k叉哈夫曼树.O(nlogn)的做法:先对所有数排序,另外一个队列维护合并后的值,取值时从两个序列前端取小的即可. 注:如果(n-1)%(k-1)!=0,那么就要增加(k-1-(n-1)%(k-1))个权值为0的叶子节点作虚拟点. 1 #include<cstdio> 2 #inc

POJ 3253 Fence Repair 类似哈夫曼树的贪心思想

Fence Repair Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 24550   Accepted: 7878 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)

最小优先队列实现赫夫曼树 贪心策略

使用 最小优先队列存放要编码的key,和合并之后内部节点,注意最小优先队列,获得最小值时会把最小是删掉,下面是java实现. package Algorithms; class MinQueue<T extends Comparable<? super T>>{ int heapSize; T[] heap; int capacity; public MinQueue(int capaticty) { this.capacity=capaticty; heapSize=0; //因

赫夫曼树JAVA实现及分析

一,介绍 1)构造赫夫曼树的算法是一个贪心算法,贪心的地方在于:总是选取当前频率(权值)最低的两个结点来进行合并,构造新结点. 2)使用最小堆来选取频率最小的节点,有助于提高算法效率,因为要选频率最低的,要么用排序,要么用堆.用堆的话,出堆的复杂度为O(logN),而向堆中插入一个元素的平均时间复杂度为O(1),在构建赫夫曼树的过程中,新生成的结点需要插入到原来的队列中,故用堆来维持这种顺序比排序算法要高效地多. 二,赫夫曼算法分析 ①用到的数据结构分析 首先需要构造一棵赫夫曼树,因此需要二叉链

哈夫曼树---POJ3253

http://poj.org/problem?id=3253 这就是 最典型的哈夫曼树的题型,我们就根据这道题学习一下哈夫曼树 这是最开始我们把21据下来之后我们据下8,然后再据下5得到34,可以看出13被用到2次,8被用到1次13*2+8=34. 这幅图片,我们先据下21,再据下5,再据下8得到34,即16*2+5=37. 所以,对于这道题,我们运用贪心的思想和哈夫曼树 1 #include<queue> 2 #include<stdio.h> 3 using namespace

poj 3253 哈夫曼树

背景 :开始自己想了一个贪心思路,结果是错的.其实这个题是哈夫曼树的思想,贪心只是哈夫曼树的证明和构造思想. 哈夫曼树:一种带权最短二叉树(也就是所有叶子节点的权重乘以深度的和最小),在实际中是用来做最高效信息编码的.信息的频率就是权重,一个频率很低的数,它的编码就应该长,树的深度就应该大.实际信息编码会根据信息字符的频率来构建一个哈夫曼树,已达到最高效. 本题和哈夫曼树是一个很好的契合,解决本题的贪心思想也是构建哈夫曼树的方法,以最小的两个元素为最后砍开的段,然后把这两个元素加起来,就可以构成