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); } } } }
int main(void) { scanf("%u %u", &words, &maxLength); for(unsigned int w = 0; w < words; ++ w) { scanf("%s", word); sWord[w] = std::string(word); que.push(sWord[w]); } while(!que.empty() && que.top().length() <= maxLength) { act = que.top(); que.pop(); if(isPalindrome(act)) { ++ result; if(result == 835454957) result = 0; } for(unsigned int w = 0; w < words; ++ w) que.push(act + " " + sWord[w]); } printf("%u\n", result); return 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; }
// this inline void scheduler_loop() { std::unique_ptr<Priority> pCurrentPrty; for (;;) { std::unique_lock<std::mutex> lock(queue_mutex); // wait for some task to get queued or for the atomic // isActive flag to become inactive condition.wait(lock, [this, &pCurrentPrty] { if (!mTasks.empty() && pCurrentPrty && pCurrentPrty->getPriorityStr() != mTasks.top().getPriority().getPriorityStr() && pCurrentPrty->getPriorityStr().length() != mTasks.top().getPriority().getPriorityStr().length()) { std::cout << "priority change" << std::endl; } return (!mTasks.empty() || !isActive.load()); }); // only exit when no more tasks on the queue if (!isActive.load() && mTasks.empty()) { return; } // update the top priority job that is currently running pCurrentPrty = std::make_unique<Priority>(mTasks.top().getPriority()); // move next task off the priority queue auto nextTask(std::move(mTasks.top())); pCurrentPrty = std::make_unique<Priority>(nextTask.getPriority()); // queue housekeeping mTasks.pop(); // release the lock allowing new entries to be queued lock.unlock(); // execute the task forwarding stored arguments with the call // this is the magic that works inside a thread pool // _Ret operator()(_Types... _Args) const nextTask(); } }
// preferences should be a member wns::scheduler::ConnectionID ProportionalFair::getNextConnection(SchedulerStatePtr schedulerState, std::priority_queue<UserPreference> preferences) { wns::scheduler::ConnectionID next = -1; while (!preferences.empty()) { int priority = schedulerState->currentState->getCurrentPriority(); const float preference = preferences.top().first; const UserID user = preferences.top().second; MESSAGE_SINGLE(NORMAL, logger, "Selected user="******"Selected connection with CID="<<next); return next; } preferences.pop(); } return next; }
int main() { scanf("%d %d", &n, &m); for (int i = 0; i < m; i++) { scanf("%d %d %d", &a, &b, &t); adj[a].push_back(std::make_pair(b, t)); adj[b].push_back(std::make_pair(a, t)); } dist[0] = 0; q.push(std::make_pair(0, 0)); for (int i = 1; i < n; i++) { dist[i] = 0x3f3f3f3f; q.push(std::make_pair(-dist[i], i)); } while (!q.empty()) { std::tie(cur_dist, cur_index) = q.top(); q.pop(); cur_dist *= -1; vis[cur_index] = 1; for (std::pair<int, int> p : adj[cur_index]) { if (!vis[p.first]) { const int alt = cur_dist + p.second; if (alt < dist[p.first]) { dist[p.first] = alt; q.push(std::make_pair(-alt, p.first)); } } } } dist2[0] = 0; q.push(std::make_pair(0, n - 1)); for (int i = 0; i < n - 1; i++) { dist2[i] = 0x3f3f3f3f; q.push(std::make_pair(-dist2[i], i)); } while (!q.empty()) { std::tie(cur_dist, cur_index) = q.top(); q.pop(); cur_dist *= -1; vis2[cur_index] = 1; for (std::pair<int, int> p : adj[cur_index]) { if (!vis2[p.first]) { const int alt = cur_dist + p.second; if (alt < dist2[p.first]) { dist2[p.first] = alt; q.push(std::make_pair(-alt, p.first)); } } } } for (int i = 0; i < n; i++) { ans = std::max(ans, dist[i] + dist2[i]); } printf("%d\n", ans); }
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; }
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); } }
void dijkstra() { std::fill(d + 1, d + n + 1, INF); for (int i = 1; i <= n; i++) { if (!w[i]) continue; heap.push((Heapnode){d[i] = 0, i}); } while (!heap.empty()) { Heapnode top = heap.top(); heap.pop(); if (v[top.node]) continue; v[top.node] = true; for (int i = h[top.node]; i; i = e[i].next) if (!v[e[i].node] && d[e[i].node] > top.dist + e[i].dist) { d[e[i].node] = top.dist + e[i].dist; p[e[i].node] = top.node; heap.push((Heapnode){d[e[i].node], e[i].node}); } } s = 0; for (int i = 1, cnt = 0; i <= n; i++) { if (!w[i]) continue; c[i] = ++s; } for (int i = 1; i <= n; i++) { if (w[i]) continue; fa[getfa(i)] = getfa(p[i]); } for (int i = 1; i <= n; i++) { if (w[i]) continue; c[i] = c[getfa(i)]; } }
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; }
Node::Ptr peek() const { if (queue.empty()) return Node::Ptr(); Node::Ptr result = queue.top(); return result; }
PLUGIN_EXPORT int PLUGIN_CALL AmxUnload(AMX * amx) { std::priority_queue<struct timer_s *, std::deque<struct timer_s *>, TimerCompare> cleaned; // Destroy all the timers for this mode. while (!gTimers.empty()) { struct timer_s * next = gTimers.top(); gTimers.pop(); if (next->amx == amx) { // Ending, remove from the map also. gHandles.erase(next->id); } else { // Not ending, leave it be. cleaned.push(next); } } gTimers = cleaned; for (int i = 0; i != 17; ++i) { if (gAMXFiles[i] == amx) { gAMXFiles[i] = 0; break; } } return AMX_ERR_NONE; }
/** * Recursively search the decision tree over the acting agents. * * TODO: I want a custom priority queue here, which can be quickly reset and copied */ float doSearch( WorldStateInterface* progressiveWorldState, std::priority_queue<AgentStateInterface*> agentQueue, int depth) { if (depth <= 0) { // TODO: evaluate the state return 0; } WorldStateInterface::SnapshotInterface* snapshot = progressiveWorldState->takeSnapshot(); AgentStateInterface* actingAgent = agentQueue.top(); agentQueue.pop(); std::list<ActionInterface*> actions = actingAgent->getPossibleActions(); float best = 0, score = 0; for (std::list<ActionInterface*>::iterator iter = actions.begin(); iter != actions.end(); ++iter) { (*iter)->doAction(); score = doSearch(progressiveWorldState, agentQueue, depth - 1); progressiveWorldState->restoreShapshot(snapshot); if (score > best) { best = score; } } return best; }
/** * decode next alignment * * @param algn reference to alignment object to be filled * @return true iff next alignment could be read, false when no more alignments are available **/ bool readAlignment(libmaus::bambam::BamAlignment & algn) { if ( Q.empty() ) return false; uint64_t const t = Q.top(); Q.pop(); libmaus::bambam::BamAlignment::D_array_type T = algn.D; algn.D = data[t].D; algn.blocksize = data[t].blocksize; data[t].D = T; data[t].blocksize = 0; if ( index[t].second-- ) { #if !defined(NDEBUG) bool const alok = #endif libmaus::bambam::BamDecoder::readAlignmentGz(*(streams[t]),data[t],0,false); #if !defined(NDEBUG) assert ( alok ); #endif Q.push(t); } return true; }
Node::Ptr pop() { if (queue.empty()) return Node::Ptr(); Node::Ptr result = queue.top(); queue.pop(); return result; }
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; }
int main() { freopen("F.in", "r", stdin); while (scanf("%d%d", &n, &m) == 2 && n && m) { for (int i = 1; i <= n; i++) { scanf("%s", map[i] + 1); } scanf("%d%d", &sx, &sy); scanf("%d%d", &ex, &ey); for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) { v[i][j] = false; d[i][j] = INF; } heap.push(std::make_pair(d[sx][sy] = 0, std::make_pair(sx, sy))); while (!heap.empty()) { std::pair<int, std::pair<int, int> > top = heap.top(); heap.pop(); if (v[top.second.first][top.second.second]) continue; v[top.second.first][top.second.second] = true; for (int dir = 0; dir < 4; dir++) { int nx = top.second.first + dx[dir]; int ny = top.second.second + dy[dir]; if (nx < 1 || nx > n || ny < 1 || ny > m) continue; int cost = map[nx][ny] == '.'; if (!v[nx][ny] && d[nx][ny] > d[top.second.first][top.second.second] + cost) { d[nx][ny] = d[top.second.first][top.second.second] + cost; heap.push(std::make_pair(d[nx][ny], std::make_pair(nx, ny))); } } } printf("%d\n", d[ex][ey]); } return 0; }
void operator<<(std::priority_queue<_Tp,Range,Compare> lhs) { for(;!lhs.empty();){ std::cout<<lhs.top()<<token; lhs.pop(); } std::cout<<last_token<<std::flush; }
inline P top_priority(void) const { delay_mtx.lock(); P ret(data.top().priority); delay_mtx.unlock(); return ret; }
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(); }
inline T pop(void) { delay_mtx.lock(); T ret(data.top().item); data.pop(); delay_mtx.unlock(); return ret; }
// 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)); } } }
int Merge(const int num) { int ret = 0; for (int i=0; i<num; i++) { ret += sands.top(); sands.pop(); } ans += ret; return ret; }
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(); } }
double NextTime() { //std::lock_guard<std::mutex> lock(MUTEX); if( QUEUE.empty() ) { return 0; } else { return QUEUE.top(); } }
void simulation::run () { while (! eventQueue.empty ()) { event * nextEvent = eventQueue.top (); eventQueue.pop (); time = nextEvent->time; nextEvent->processEvent (); delete nextEvent; } }
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; };
// Output the Queue void display(std::priority_queue<Node>& q){ // reverse std::vector<Node> v; v.reserve(K); while (!q.empty()){ v.push_back(q.top()); q.pop(); } for(int i=K;i>0;i--){ PrintfNode(v[i-1]); } }
void rearrange(Attributes *attr, TWeight score) { AttrsPtr a; while ((a = opened.top()), opened.pop(), (a.pa != attr)) temp_buff.push_back(a); a.pa->fscore = score; opened.push(a); while (!temp_buff.empty()) { opened.push(temp_buff.back()); temp_buff.pop_back(); } }