Exemple #1
0
void Median::insert(int value)
{
   size_t l = maxHeap1.size();
   size_t m = minHeap2.size();
   if (l - m == 0) {
      if (l != 0 && value > maxHeap1.top()) {
         minHeap2.push(value);
      } else {
         maxHeap1.push(value);
      }
   } else if (labs(l - m) == 1) {
      if (l > m) {
         if (maxHeap1.top() > value) {
            int r = maxHeap1.top();
            maxHeap1.pop();
            minHeap2.push(r);
            maxHeap1.push(value);
         } else {
            minHeap2.push(value);
         }
      } else {
         if (minHeap2.top() < value) {
            int r = minHeap2.top();
            minHeap2.pop();
            maxHeap1.push(r);
            minHeap2.push(value);
         } else {
            maxHeap1.push(value);
         }
      }
   }
}
double getMedian(const std::priority_queue<double, std::vector<double>, std::greater<double> >& m,
		const std::priority_queue<double>& M){

	if(m.size() > M.size()) // There are an odd number of observations
		return m.top();
	else if(M.size() > m.size()) // There are an odd number of observations
		return M.top();
	else // There are an even number of obersations
		return (m.top()+M.top())/2;
}
//Maintains the size of the priority queue at the specified size bound with each push
//For now this function is for priority queue that is in ascending order, top is smallest.
//Returns result: 0 if not added, 1 if pushed without pop, 2 if pushed & popped
int pushBoundedPriorityQueue(std::priority_queue<int, std::vector<int>, std::greater<int> >  &pq,
                              int element, long bound)
{
   int result = 0;
   if(pq.size() < bound || element > pq.top()){
      pq.push(element);
      result = 1;
      if(pq.size() > bound){
         pq.pop();
         result = 2;
      }
   }
   return result;
}
Exemple #4
0
int main(void)
{
    while(scanf("%d", &numbers) != -1 && numbers)
    {
        result = 0;
        for(int n = 0; n < numbers; ++ n)
        {
            scanf("%d", &number);
            que.push(number);
        }

        while(que.size() > 1)
        {
            int first = que.top(); que.pop();
            int second = que.top(); que.pop();
            que.push(first + second);
            result += first + second;
        }

        que.pop();
        printf("%lld\n", result);
    }

    return 0;
}
int expand()
{
    Nodes node= nodes.top();
   
    if(nodes.size()==0)
    {
             cout<<"error";
             getch();
             return 0;
    }                  
    nodes.pop();
    if(visited[node.node]==1)
         return 0;
    else 
         visited[node.node]=1;
         
    if(node.node==end)
    {
       cout<<"Minimum delay from source to destination device:"<<node.cost;
       return 1;
    }
    else
    {
        for(int j=0;j<n;j++)
        {
           if(a[j][node.node]!=0)
           {
                nodes.push(Nodes(j,node.cost+a[j][node.node]));
           }
        }    
        
    }
   return 0;
}
int expand()
{
    Nodes node= nodes.top();
    getch();
    if(nodes.size()==0)
    {
             cout<<"error";
             getch();
             return 0;
    }                  
    nodes.pop();
    if(visited[node.node]==1)
         return 0;
    else 
         visited[node.node]=1;
         
    if(node.node==end)
    {
       cout<<"finalcost"<<node.cost;
       return 1;
    }
    else
    {
        for(int j=0;j<n;j++)
        {
           if(a[j][node.node]!=0)
           {
                nodes.push(Nodes(j,node.cost+a[j][node.node]));
           }
        }    
        
    }
   return 0;
}
Exemple #7
0
double Median::getMedian(void)
{
   size_t l = maxHeap1.size();
   size_t m = minHeap2.size();
   if (l == 0 && m == 0) {
      throw std::invalid_argument("No elements inserted yet");
   }
   if (l - m == 0) {
      return (maxHeap1.top() + minHeap2.top()) / 2.0;
   } else {
      if (l > m) {
         return maxHeap1.top();
      } else {
         return minHeap2.top();
      }
   }
}
//Maintains the size of the priority queue at the specified size with each push
//For now this function is for priority queue that is in ascending order, top is smallest.
void pushPriorityQueueBounded(std::priority_queue<int, std::vector<int>, std::greater<int> >  &pq,
                              int newElement, unsigned long priorityQueueBound)
{
   if(pq.empty() || newElement > pq.top())
      pq.push(newElement);
   if(pq.size() > priorityQueueBound)
      pq.pop();
}
void UCS()
{
     int check=0;
     nodes.push(Nodes(start,0));
     visited[start]=0;
     cout<<nodes.size();
     while(check==0) 
     check=expand();
}
// Update the Queue. If the queue size less than K, just push.
// Otherwise, if the new value less than the max value, delete the max
// and push new node into queue.
void updataQ(std::priority_queue<Node>& q, RealT d, int i){
  if(q.size() < K) q.push(Node(i,d));
  else{
    if(q.top().dis > d){
      q.pop();
      q.push(Node(i,d));
    }
  }
}
void AddToHeaps(std::priority_queue<double, std::vector<double>, std::greater<double> >& m,
		std::priority_queue<double>& M, double x){

	// decide on initial heap to place element into
	if(m.empty() || x < m.top())
		M.push(x);
	else
		m.push(x);
	// make sure that heaps are balanced
	if(m.size() > M.size() + 1){
		M.push( m.top() );
		m.pop();	
	}
	else if(M.size() > m.size() + 1){
		m.push( M.top() );
		M.pop();
	}
}
Exemple #12
0
void checkCollision() {
    int i, j;
    if ( events.size()!=0) {
        while( elapsedTime >= events.top().timeOccuring)
        {
            i = events.top().i;

            if( checkOutdated( events.top() ) ) {
                printf("---POOPZIES of %d, timeInserted=%f, lastCollition=%f\n",
                       i, events.top().timeInserted, sphere[i].lastCollision );
                events.pop();
            } else if (events.top().j!=-1) {
                j = events.top().j;

                sphere[i].q0 += (events.top().timeOccuring - sphere[i].t0) * sphere[i].speedVec;
                sphere[i].speedVec = sphere[i].newSpeedVec;
                sphere[i].t0 = events.top().timeOccuring;

                sphere[j].q0 += (events.top().timeOccuring - sphere[j].t0) * sphere[j].speedVec;
                sphere[j].speedVec = sphere[j].newSpeedVec;
                sphere[j].t0 = events.top().timeOccuring;

                sphere[i].cols++;
                sphere[j].cols++;

                events.pop();
                calculateCollision(i);
                calculateCollision(j);
                printf("BALLZIES of %d, timeInserted=%f, lastCollition=%f\n",
                       i, events.top().timeInserted, sphere[i].lastCollision );
            } else {
                sphere[i].q0 += (events.top().timeOccuring - sphere[i].t0) * sphere[i].speedVec;
                sphere[i].speedVec = sphere[i].newSpeedVec;
                sphere[i].t0 = events.top().timeOccuring;

                sphere[i].cols++;

                events.pop();
                calculateCollision(i);
                printf("WALLZIES of %d, timeInserted=%f, lastCollition=%f\n",
                       i, events.top().timeInserted, sphere[i].lastCollision );
            }
        }
        //std::vector<Sphere>::iterator it = sphereIterInit;
        //for(it; it != sphere.end();it++){
        //	position = it->q0 + (float)(elapsedTime - it->t0) * it->speedVec;
        //	if(abs(position.x)>0.96f || abs(position.y)>0.96f || abs(position.z)>0.96f){
        //		printf("WHAT THE F**K MOAR BUGS PLS!!!!!AAAAAAAAAAARRGGH\n");
        //	}
        //}


        minmin = (events.top().timeOccuring<minmin)?events.top().timeOccuring:minmin;
    }
}
	bool pop_front(T& data)
	{
		std::lock_guard<std::mutex> guard(mtx);
		if (pq.size() > 1)
		{
			data = pq.top();
			pq.pop();
			return true;
		}
		return false;
	};
int main()
{
	scanf( "%d", &N );
	REP(i, N)
	{
		int x;
		scanf( "%d", &x );
		pq.push(x);
		while (pq.size() > N / 2 + 1)
		      pq.pop();
	}
	// Helper function that searches the tree    
	void search(Node* node, const T& target, int k, std::priority_queue<HeapItem>& heap)
	{
		if(node == NULL) return;     // indicates that we're done here

		// Compute distance between target and current node
		ScalarType dist = distance(_items[node->index], target);

		// If current node within radius tau
		if(dist < _tau) {
			if(heap.size() == static_cast<size_t>(k)) heap.pop(); // remove furthest node from result list (if we already have k results)
			heap.push(HeapItem(node->index, dist));           // add current node to result list
			if(heap.size() == static_cast<size_t>(k)) _tau = heap.top().dist;     // update value of tau (farthest point in result list)
		}

		// Return if we arrived at a leaf
		if(node->left == NULL && node->right == NULL) {
			return;
		}

		// If the target lies within the radius of ball
		if(dist < node->threshold) {
			if(dist - _tau <= node->threshold) {         // if there can still be neighbors inside the ball, recursively search left child first
				search(node->left, target, k, heap);
			}

			if(dist + _tau >= node->threshold) {         // if there can still be neighbors outside the ball, recursively search right child
				search(node->right, target, k, heap);
			}

			// If the target lies outsize the radius of the ball
		} else {
			if(dist + _tau >= node->threshold) {         // if there can still be neighbors outside the ball, recursively search right child first
				search(node->right, target, k, heap);
			}

			if (dist - _tau <= node->threshold) {         // if there can still be neighbors inside the ball, recursively search left child
				search(node->left, target, k, heap);
			}
		}
	}
Exemple #16
0
void update_world(double frame_start,double tot_time){

        double frame_stop = current_time+tot_time;
        double dt;
        
        ObjectPair* pair;
        
        if(pairs.size() > 0 ){
                while( pairs.top()->wake_up < frame_stop){

                        pair = pairs.top();
			// cout << "Popped pair: " << pair->id << ".\n";
                        
                        dt = pair->wake_up - pair->sim_time();
                        if( dt < min_dt)
                                dt=min_dt;
                        
                        //the object will be simulated this far when the loo has ended
                        
                        pairs.pop();
                        pair->simulate(dt);
                                                
                        if(pair->has_collided()){
                                Collision col = pair->get_collision();
                                pair->collide(col);
                                pair->simulate(min_dt);
                                        
                              while(pair->has_collided()){
                                      pair->simulate(min_dt);
                              }
                               
                        }

                

			//		cout << "Before -- Pair: " << pair->id << " Wake_up: " << pair->wake_up << ".\n";
		pair->calc_wake_up();
		//		cout << "After -- Pair: " << pair->id << " Wake_up: " << pair->wake_up << ".\n";

                pairs.push(pair);// bara om de inte har dött
                }                
        }
        
        
        for(int i = 0; i < objects.size(); i++){
                dt = frame_stop - objects[i]->sim_time;
                if(dt > 0)
                    objects[i]->simulate(dt);
        }


}
int main() {
	ll n;
	cin>>n;
	while(n>0){
		while(pq.size()) pq.pop();
		for (int i = 0; i < n; ++i)
		{
			ll x;
			cin>>x;
			pq.push(x);
		}
		ll ans=0;
		while(pq.size()!=1){
			ll a=pq.top();pq.pop();
			ll b=pq.top();pq.pop();
			ans+=(a+b);
			pq.push(a+b);
		}
		cout<<ans<<endl;
		cin>>n;
	}
	return 0;
}
	bool contains(T data) 
	{
		std::lock_guard<std::mutex> guard(mtx);
		if (pq.size() > 1)
		{
			std::vector<T> *queue_vector;
		        //recast the priority queue to vector
		        queue_vector = reinterpret_cast<std::vector<T> *>(&pq);
        		for(typename std::vector<T>::iterator it = (*queue_vector).begin(); it != (*queue_vector).end(); it++) 
			{
				if (data == *it)
					return true;
			}
		}
		return false;
	}
Exemple #19
0
int main() {
	freopen("1757.in" , "r", stdin );
	freopen("1757.out", "w", stdout);

	scanf("%d %d", &n, &m);
	for (int i=0, cur; i<n; i++) {
		scanf("%d", &cur);
		sands.push(cur);
	}

	const int first = (n - 2) % (m - 1) + 2;
	sands.push(Merge(first));
	for (; sands.size() > 1; )
		sands.push(Merge(m));
	printf("%d\n", ans);

	return 0;
}
int main(){
	int n;
	while(scanf("%d",&n)!=EOF&&n){
		while(!L.empty())L.pop();
		int i,res=0,t;
		num x,y;
		for(i=1;i<=n;i++){
			scanf("%d",&t);
			L.push( (num){t} );
			}
		while(L.size()>1){
			x=L.top();L.pop();
			y=L.top();L.pop();
			res+=x.x+y.x;
			if(L.empty())break;
			L.push( (num){x.x+y.x} );
			}
		printf("%d\n",res);
		}
	return 0;
	}
Exemple #21
0
void AI::publishThreeComponentRHL(std::priority_queue < std::pair<double, cv::Point2d>, 
    std::vector<std::pair<double, cv::Point2d> >, 
    AI::CompareComponentsWithDeviation> largestThreeComponentQueue) {
    
    //create message
    robia::points_tuple message;
    
    if (largestThreeComponentQueue.size() != 3) {
      // Left Hand, Head, Right hand
      message.Rx = -1;
      message.Ry = -1;
      message.Hx = -1;
      message.Hy = -1;
      message.Lx = -1;
      message.Ly = -1;
    } else {    
      std::vector<cv::Point2d> largestThreeComponentVector;

      while(!largestThreeComponentQueue.empty()) {
        largestThreeComponentVector.push_back(largestThreeComponentQueue.top().second);
        largestThreeComponentQueue.pop();
      }

      std::sort(largestThreeComponentVector.begin(), largestThreeComponentVector.end(), comparePointsWithRespectToX);

      // Left Hand, Head, Right hand
      message.Rx = largestThreeComponentVector[0].x/LengthOfCamera;
      message.Ry = largestThreeComponentVector[0].y/HeightOfCamera;
      message.Hx = largestThreeComponentVector[1].x/LengthOfCamera;
      message.Hy = largestThreeComponentVector[1].y/HeightOfCamera;
      message.Lx = largestThreeComponentVector[2].x/LengthOfCamera;
      message.Ly = largestThreeComponentVector[2].y/HeightOfCamera;
    }

    // Publish three points to ROSTopic 
    pubThreePointsPositions.publish(message);

  }
void runSaltBridgeMC(
		     subSeq &_exposedPositions,
		     map<string,map<string,map<int, map<string,map<string, double> > > > > &_sbScoreTable,
		     System &_sys, 
		     Options &_opt,
		     std::priority_queue< std::pair<saltBridgeResult,subSeq>, std::vector< std::pair<saltBridgeResult,subSeq> >, compareScores> &_mcData){

  // WT score
  saltBridgeResult wt_sbresult = scoreSaltBridgePositions(_exposedPositions,_sbScoreTable,_sys);

  // Map to insure we don't fill priority queue with duplicates
  map<string,bool> mcDataMap;

  string possibleMutations = "KREDH";

  RandomNumberGenerator rng;
  rng.setTimeBasedSeed();
  MSLOUT.stream() << "RNG SEED: "<<rng.getSeed()<<endl;

  //MonteCarloManager MCMngr(_startingTemperature, _endingTemperature,_scheduleCycles, _scheduleShape, _maxRejectionsNumber, _convergedSteps, _convergedE);
  MonteCarloManager MCMngr(_opt.startMCtemp,_opt.endMCtemp,_opt.numMCcycles, MonteCarloManager::EXPONENTIAL,100,0,0.0);
  MCMngr.setRandomNumberGenerator(&rng);
  MCMngr.setEner(wt_sbresult.score);
  
  subSeq current   = _exposedPositions;
  string wtSeq     = _exposedPositions.seq;

  // TODO add options to Options opt; to take care of MC-related options..... get rid of hard-coded values.

  while (!MCMngr.getComplete()) {
    
    // Make change
    int mutIndex = rng.getRandomInt(0,possibleMutations.size()-1);
    int seqPosIndex = rng.getRandomInt(0,_exposedPositions.seq.size()-1);
    string mutAA = possibleMutations.substr(mutIndex,1);
    string previousAA = current.seq.substr(seqPosIndex,1);
    current.seq.replace(seqPosIndex,1,mutAA);

    // Eval
    saltBridgeResult sbResult = scoreSaltBridgePositions(current,_sbScoreTable,_sys);
    //MSLOUT.stream() << "SCORE: "<<score<<" wt: "<<wt_score<<endl;

    // MC test for Acceptance:
    if (MCMngr.accept(sbResult.score)){

      //cout << "New SEQ: "<<current.seq<<" score: "<<score<<endl;
      //cout << "WT  SEQ: "<<wtSeq<<" score: "<<wt_score<<endl;
      bool keepIt = false;
      map<string, bool>::iterator it;
      it = mcDataMap.find(sbResult.sbId);
      if (it == mcDataMap.end()){
	mcDataMap[sbResult.sbId] = true;
	if (_mcData.size() >= _opt.numSequenceModels){
	  if (sbResult.score < _mcData.top().first.score){
	    // Remove highest score, then add
	    _mcData.pop();
	    _mcData.push(pair<saltBridgeResult,subSeq>(sbResult,current));
	    keepIt = true;
	  }

	} else {
	  _mcData.push(pair<saltBridgeResult,subSeq>(sbResult,current));
	  keepIt = true;
	}

      } 
      if (!keepIt){
	current.seq.replace(seqPosIndex,1,previousAA);
      }
    } else {
      current.seq.replace(seqPosIndex,1,previousAA);
   }
  }
  MSLOUT.stream() << "MC Completed -> "<<MCMngr.getReasonCompleted()<<endl;

}
Exemple #23
0
	size_t size() const
	{
		return queue.size();
	}
void dijkstra_pq_thread(CSRGraph *g, int *dist, std::priority_queue<Priority_struct, std::vector<Priority_struct>, Compare_priority> &pq, int threadNum, std::mutex *dist_locks)
{
    while(!pq.empty())
    {
        queue_lock.lock();

        if(pq.empty())
        {
            queue_lock.unlock();
            break;
        }

        Priority_struct temp_struct = pq.top();
        int u = temp_struct.node_name;
        pq.pop();
	
    printf("Popped\n");
    for(int i=0; i< pq.size();i++){
	printf(" %d", pq[i]);
    }
    printf("\n");

        int udist = dist[u];

        queue_lock.unlock();

        std::vector<int> neighbors = CSRGraph_getNeighbors(g, u);

        int neighbor;
        for(neighbor=0;neighbor < neighbors.size(); neighbor++)
        {
            int v = neighbors[neighbor];
            int uvdist = CSRGraph_getDistance(g, u, v);
            int alt = udist + uvdist;

            dist_locks[v].lock();
            if(alt < dist[v])
            {
                dist[v] = alt;
                dist_locks[v].unlock();

                Priority_struct temp2;
                temp2.node_name=v;
                temp2.node_weight = uvdist;

                queue_lock.lock();                
                pq.push(temp2);
		
    printf("Pushed\n");
    for(int i=0; i< pq.size();i++){
	printf(" %d", pq[i]);
    }
    printf("\n");
                queue_lock.unlock();                    
            }
            else
            {
                dist_locks[v].unlock();
            }
        }
    }

    //printf("Thread %d ended.\n", threadNum);
}
 inline size_t size(void) const
 {
     return data.size();
 }
	size_t size() const
	{
		std::lock_guard<std::mutex> guard(mtx);
		return pq.size();
	};