vector<pair<int, int>> reconstructQueue(vector<pair<int, int>>& people)
{
if (people.size() < 2)
{
return people;
}
int n = people.size();
for (int i = 0; i < n; i++)
{
people[i].second = n - people[i].second;
}
sort(people.begin(), people.end());
for (int i = 0; i < n; i++)
{
people[i].second = n - people[i].second;
}
Node* tree = build_tree(0, n);
vector<pair<int, int>> result;
result.resize(n);
for (int i = 0; i < n; i++)
{
int position = place_in_tree(tree, people[i].second);
#ifdef LOG
cout << "Searching for " << people[i].first << ", " << people[i].second << endl;
cout << "===================" << endl;
print(tree, 0);
cout << "===================" << endl;
cout << position << endl;
#endif
result[position] = people[i];
}
return result;
}
int place_in_tree(Node* tree, int position)
{
tree->sum--;
if (tree->left == NULL)
{
if (position != 0) { throw 1; }
return tree->begin;
}
else
{
if (position < tree->left->sum)
{
return place_in_tree(tree->left, position);
}
else
{
return place_in_tree(tree->right, position - tree->left->sum);
}
}
}
static PetscErrorCode get_ngh_buf(gs_id *gs)
{
PetscInt i, j, npw=0, ntree_map=0;
PetscInt p_mask_size, ngh_buf_size, buf_size;
PetscInt *p_mask, *sh_proc_mask, *pw_sh_proc_mask;
PetscInt *ngh_buf, *buf1, *buf2;
PetscInt offset, per_load, num_loads, or_ct, start, end;
PetscInt *ptr1, *ptr2, i_start, negl, nel, *elms;
PetscInt oper=GL_B_OR;
PetscInt *ptr3, *t_mask, level, ct1, ct2;
PetscErrorCode ierr;
PetscFunctionBegin;
/* to make life easier */
nel = gs->nel;
elms = gs->elms;
level = gs->level;
/* det #bytes needed for processor bit masks and init w/mask cor. to my_id */
p_mask = (PetscInt*) malloc(p_mask_size=len_bit_mask(num_nodes));
ierr = set_bit_mask(p_mask,p_mask_size,my_id);CHKERRQ(ierr);
/* allocate space for masks and info bufs */
gs->nghs = sh_proc_mask = (PetscInt*) malloc(p_mask_size);
gs->pw_nghs = pw_sh_proc_mask = (PetscInt*) malloc(p_mask_size);
gs->ngh_buf_sz = ngh_buf_size = p_mask_size*nel;
t_mask = (PetscInt*) malloc(p_mask_size);
gs->ngh_buf = ngh_buf = (PetscInt*) malloc(ngh_buf_size);
/* comm buffer size ... memory usage bounded by ~2*msg_buf */
/* had thought I could exploit rendezvous threshold */
/* default is one pass */
per_load = negl = gs->negl;
gs->num_loads = num_loads = 1;
i=p_mask_size*negl;
/* possible overflow on buffer size */
/* overflow hack */
if (i<0) {i=INT_MAX;}
buf_size = PetscMin(msg_buf,i);
/* can we do it? */
if (p_mask_size>buf_size) SETERRQ2(PETSC_ERR_PLIB,"get_ngh_buf() :: buf<pms :: %d>%d\n",p_mask_size,buf_size);
/* get giop buf space ... make *only* one malloc */
buf1 = (PetscInt*) malloc(buf_size<<1);
/* more than one gior exchange needed? */
if (buf_size!=i)
{
per_load = buf_size/p_mask_size;
buf_size = per_load*p_mask_size;
gs->num_loads = num_loads = negl/per_load + (negl%per_load>0);
}
/* convert buf sizes from #bytes to #ints - 32 bit only! */
p_mask_size/=sizeof(PetscInt); ngh_buf_size/=sizeof(PetscInt); buf_size/=sizeof(PetscInt);
/* find giop work space */
buf2 = buf1+buf_size;
/* hold #ints needed for processor masks */
gs->mask_sz=p_mask_size;
/* init buffers */
ierr = ivec_zero(sh_proc_mask,p_mask_size);CHKERRQ(ierr);
ierr = ivec_zero(pw_sh_proc_mask,p_mask_size);CHKERRQ(ierr);
ierr = ivec_zero(ngh_buf,ngh_buf_size);CHKERRQ(ierr);
/* HACK reset tree info */
tree_buf=NULL;
tree_buf_sz=ntree=0;
/* ok do it */
for (ptr1=ngh_buf,ptr2=elms,end=gs->gl_min,or_ct=i=0; or_ct<num_loads; or_ct++)
{
/* identity for bitwise or is 000...000 */
ivec_zero(buf1,buf_size);
/* load msg buffer */
for (start=end,end+=per_load,i_start=i; (offset=*ptr2)<end; i++, ptr2++)
{
offset = (offset-start)*p_mask_size;
ivec_copy(buf1+offset,p_mask,p_mask_size);
}
/* GLOBAL: pass buffer */
ierr = giop(buf1,buf2,buf_size,&oper);CHKERRQ(ierr);
/* unload buffer into ngh_buf */
ptr2=(elms+i_start);
for(ptr3=buf1,j=start; j<end; ptr3+=p_mask_size,j++)
{
/* I own it ... may have to pairwise it */
if (j==*ptr2)
{
/* do i share it w/anyone? */
ct1 = ct_bits((char *)ptr3,p_mask_size*sizeof(PetscInt));
/* guess not */
if (ct1<2)
{ptr2++; ptr1+=p_mask_size; continue;}
/* i do ... so keep info and turn off my bit */
ivec_copy(ptr1,ptr3,p_mask_size);
ierr = ivec_xor(ptr1,p_mask,p_mask_size);CHKERRQ(ierr);
ierr = ivec_or(sh_proc_mask,ptr1,p_mask_size);CHKERRQ(ierr);
/* is it to be done pairwise? */
if (--ct1<=level)
{
npw++;
/* turn on high bit to indicate pw need to process */
*ptr2++ |= TOP_BIT;
ierr = ivec_or(pw_sh_proc_mask,ptr1,p_mask_size);CHKERRQ(ierr);
ptr1+=p_mask_size;
continue;
}
/* get set for next and note that I have a tree contribution */
/* could save exact elm index for tree here -> save a search */
ptr2++; ptr1+=p_mask_size; ntree_map++;
}
/* i don't but still might be involved in tree */
else
{
/* shared by how many? */
ct1 = ct_bits((char *)ptr3,p_mask_size*sizeof(PetscInt));
/* none! */
if (ct1<2) continue;
/* is it going to be done pairwise? but not by me of course!*/
if (--ct1<=level) continue;
}
/* LATER we're going to have to process it NOW */
/* nope ... tree it */
ierr = place_in_tree(j);CHKERRQ(ierr);
}
}
free((void*)t_mask);
free((void*)buf1);
gs->len_pw_list=npw;
gs->num_nghs = ct_bits((char *)sh_proc_mask,p_mask_size*sizeof(PetscInt));
/* expand from bit mask list to int list and save ngh list */
gs->nghs = (PetscInt*) malloc(gs->num_nghs * sizeof(PetscInt));
bm_to_proc((char *)sh_proc_mask,p_mask_size*sizeof(PetscInt),gs->nghs);
gs->num_pw_nghs = ct_bits((char *)pw_sh_proc_mask,p_mask_size*sizeof(PetscInt));
oper = GL_MAX;
ct1 = gs->num_nghs;
ierr = giop(&ct1,&ct2,1,&oper);CHKERRQ(ierr);
gs->max_nghs = ct1;
gs->tree_map_sz = ntree_map;
gs->max_left_over=ntree;
free((void*)p_mask);
free((void*)sh_proc_mask);
PetscFunctionReturn(0);
}