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 HeapInsert(struct FHeap *h,double *elem)
{
h->heap_n++;
h->heap[h->heap_n]=elem;
UpHeap(h->heap_n,h);
}
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;
}
