//配列をヒープする
void HeapSort(int A[], int n){
int i;
int tmp;
//ヒープを最下層の親から順に上に構築する
for(i = n/2; i >= 0; i--){
DownHeap(A, i, n);
}
//ヒープの先頭から最大値を取り出し、昇順にソートする
for(i = n; i >= 1; i--){
tmp = A[0];
A[0] = A[i];
A[i] = tmp;
DownHeap(A, 0, i-1);
}
}
//配列aをヒープする
void HeapSort(int a[], int n){
int i;
int tmp;
for(i = n/2; i >= 0; i--){
DownHeap(a, i, n);
}
for(i = n; i >= 1; i--){
tmp = a[0];
a[0] = a[i];
a[i] = tmp;
DownHeap(a, 0, i-1);
}
}
UINT32 CEncoder::RemoveSmallest()
{
UINT32 aTop = m_Heap[kSmallest];
m_Heap[kSmallest] = m_Heap[m_HeapLength--];
DownHeap(kSmallest);
return aTop;
}
int make_tree(tPACK20* data, int nparm, unsigned int freqparm[],
unsigned char lenparm[], unsigned int codeparm[])
{
int i, j, k, avail;
data->FreqTableSize = nparm;
data->TreeFreq = freqparm;
data->TreeLen = lenparm;
avail = data->FreqTableSize;
data->TreeHeapSize = 0;
data->TreeHeap[1] = 0;
for (i = 0; i < data->FreqTableSize; i++)
{
data->TreeLen[i] = 0;
if (data->TreeFreq[i])
data->TreeHeap[++data->TreeHeapSize] = i;
}
if (data->TreeHeapSize < 2)
{
codeparm[data->TreeHeap[1]] = 0;
return data->TreeHeap[1];
}
for (i = data->TreeHeapSize/2; i>=1; i--)
DownHeap(data,i);
data->SortPtr = codeparm;
do
{
i = data->TreeHeap[1];
if (i < data->FreqTableSize)
*data->SortPtr++ = i;
data->TreeHeap[1] = data->TreeHeap[data->TreeHeapSize--];
DownHeap(data,1);
j = data->TreeHeap[1];
if (j < data->FreqTableSize)
*data->SortPtr++ = j;
k = avail++;
data->TreeFreq[k] = data->TreeFreq[i] + data->TreeFreq[j];
data->TreeHeap[1] = k;
DownHeap(data,1);
data->Left[k] = i;
data->Right[k] = j;
} while (data->TreeHeapSize > 1);
data->SortPtr = codeparm;
MakeLen(data,k);
MakeTreeCode(data,nparm, lenparm, codeparm);
return k;
}
void *RemoveHeapItem(struct FHeap *h)
{
void *ret=0;
if (h->heap_n!=0)
{
ret=h->heap[1];
h->heap[1]=h->heap[h->heap_n];
h->heap_n--;
DownHeap(1,h);
}
return ret;
}
void CEncoder::BuildTree(BYTE *aLevels)
{
m_BlockBitLength = 0;
int aMaxCode = -1; // WAS = -1; largest code with non zero frequency */
// Construct the initial m_Heap, with least frequent element in
// m_Heap[kSmallest]. The sons of m_Heap[n] are m_Heap[2*n] and m_Heap[2*n+1].
// m_Heap[0] is not used.
//
m_HeapLength = 0;
UINT32 n; // iterate over m_Heap elements
for (n = 0; n < m_NumSymbols; n++)
{
if (m_Items[n].Freq != 0)
{
m_Heap[++m_HeapLength] = aMaxCode = n;
m_Depth[n] = 0;
}
else
m_Items[n].Len = 0;
}
// The pkzip format requires that at least one distance code exists,
// and that at least one bit should be sent even if there is only one
// possible code. So to avoid special checks later on we force at least
// two codes of non zero frequency.
while (m_HeapLength < 2)
{
int aNewNode = m_Heap[++m_HeapLength] = (aMaxCode < 2 ? ++aMaxCode : 0);
m_Items[aNewNode].Freq = 1;
m_Depth[aNewNode] = 0;
m_BlockBitLength--;
// if (stree) static_len -= stree[aNewNode].Len;
// aNewNode is 0 or 1 so it does not have m_ExtraBits bits
}
// The elements m_Heap[m_HeapLength/2+1 .. m_HeapLength] are leaves of the m_Items,
// establish sub-heaps of increasing lengths:
for (n = m_HeapLength / 2; n >= 1; n--)
DownHeap(n);
// Construct the Huffman tree by repeatedly combining the least two
// frequent nodes.
int aNode = m_NumSymbols; // next internal node of the tree
UINT32 aHeapMax = m_NumSymbols * 2+ 1;
do
{
n = RemoveSmallest(); /* n = node of least frequency */
UINT32 m = m_Heap[kSmallest]; /* m = node of next least frequency */
m_Heap[--aHeapMax] = n; /* keep the nodes sorted by frequency */
m_Heap[--aHeapMax] = m;
// Create a new node father of n and m
m_Items[aNode].Freq = m_Items[n].Freq + m_Items[m].Freq;
m_Depth[aNode] = (BYTE) (MyMax(m_Depth[n], m_Depth[m]) + 1);
m_Items[n].Dad = m_Items[m].Dad = aNode;
// and insert the new node in the m_Heap
m_Heap[kSmallest] = aNode++;
DownHeap(kSmallest);
}
while (m_HeapLength >= 2);
m_Heap[--aHeapMax] = m_Heap[kSmallest];
// At this point, the fields freq and dad are set. We can now
// generate the bit lengths.
GenerateBitLen(aMaxCode, aHeapMax);
// The field len is now set, we can generate the bit codes
GenerateCodes (aMaxCode);
for (n = 0; n < m_NumSymbols; n++)
aLevels[n] = BYTE(m_Items[n].Len);
}
int main () {
int minHeapSize = 0;
int maxHeapSize = 0;
int minHeap[MAX_INPUT_NUM/2+1] = {0};
int maxHeap[MAX_INPUT_NUM/2+1] = {0};
int input = 0;
while (scanf("%d", &input) == 1) {
if (maxHeapSize == 0) {
maxHeap[0] = input;
maxHeapSize++;
printf("%d\n", input);
continue;
}
else {
if (input <= maxHeap[0]) {
maxHeap[maxHeapSize] = input;
maxHeapSize++;
UpHeap(maxHeap, maxHeapSize, CompareGreater);
DownHeap(maxHeap, maxHeapSize, CompareLess);
}
else {
minHeap[minHeapSize] = input;
minHeapSize++;
UpHeap(minHeap, minHeapSize, CompareLess);
DownHeap(minHeap, minHeapSize, CompareGreater);
}
}
if (maxHeapSize - minHeapSize == 2) {
minHeap[minHeapSize] = maxHeap[0];
minHeapSize++;
UpHeap(minHeap, minHeapSize, CompareLess);
DownHeap(minHeap, minHeapSize, CompareGreater);
maxHeap[0] = maxHeap[maxHeapSize-1];
maxHeapSize--;
DownHeap(maxHeap, maxHeapSize, CompareLess);
}
if (minHeapSize - maxHeapSize == 2) {
maxHeap[maxHeapSize] = minHeap[0];
maxHeapSize++;
UpHeap(maxHeap, maxHeapSize, CompareGreater);
DownHeap(maxHeap, maxHeapSize, CompareLess);
minHeap[0] = minHeap[minHeapSize-1];
minHeapSize--;
DownHeap(minHeap, minHeapSize, CompareGreater);
}
if (maxHeapSize == minHeapSize) {
printf("%d\n", (maxHeap[0] + minHeap[0]) / 2);
}
else if (maxHeapSize > minHeapSize) {
printf("%d\n", maxHeap[0]);
}
else {
printf("%d\n", minHeap[0]);
}
}
return 0;
}
void FuncCodingFisherVector (float * data, float * coding, int * coding_bin, const CodingOpt * opt)
{
// codebook data
const FisherVectorCodeBook * cb = &opt->fv_codebook;
int nDim = cb->nDim, nBase = cb->nBase;
const double * base = cb->base, *priors = cb->priors,
* invSigma = cb->invSigma,
* sqrtInvSigma = cb->sqrtInvSigma,
* sumLogSigma = cb->sumLogSigma;
// initialize for prob computation
double probtemp = 0;
int indi = 0;
int heap_size = 1;
double * prob_val = new double[opt->block_num];
int * prob_bin = new int[opt->block_num];
prob_val[0] = -1;
// find high probability GMM
for (int i=0; i<nBase; i++){
probtemp = sumLogSigma[i];
for (int k=0; k<nDim; k++)
probtemp += ((double)data[k]-base[indi+k])*((double)data[k]-base[indi+k])*invSigma[indi+k];
probtemp *= -0.5;
indi = indi+nDim;
// a min-heap to keep max prob centers
if(heap_size < opt->block_num)
{
UpHeap(prob_val, prob_bin, &heap_size, probtemp, i);
}
else if(probtemp > prob_val[0])
{
DownHeap(prob_val, prob_bin, &heap_size);
UpHeap(prob_val, prob_bin, &heap_size, probtemp, i);
}
}
double probsum = 0;
// normalize probs
for (int i=0; i<opt->block_num; i++){
int bin = prob_bin[i];
prob_val[i] = exp(prob_val[i])*priors[bin];
probsum += prob_val[i];
}
for (int i=0; i<opt->block_num; i++){
prob_val[i] /= probsum;
// coding[i] = (float)prob_val[i];
}
// coding vector
for (int i=0; i<opt->block_num; i++){
int bin = prob_bin[i];
coding_bin[i] = bin;
double sqrt_prior = cb->sqrtPrior[bin],
sqrt_2_prior = cb->sqrt2Prior[bin];
for (int k=0; k<nDim; k++){
double diff = (data[k]-base[bin*nDim+k]);
// temp = sign(temp)*MIN(maxsqrtSigma[i*nDim+k],fabs(temp));
#ifdef FIRST_ORDER
coding[i*nDim+k] = (float)(prob_val[i]*diff*sqrtInvSigma[bin*nDim+k]/sqrt_prior);
#else
coding[i*nDim*2+k] = (float)(prob_val[i]*diff*sqrtInvSigma[bin*nDim+k]/sqrt_prior);
coding[i*nDim*2+k+nDim] = (float)((prob_val[i]*diff*diff*invSigma[bin*nDim+k]-prob_val[i])/sqrt_2_prior);
#endif
}
}
delete [] prob_val;
delete [] prob_bin;
}
