int main(){ ios::sync_with_stdio(false); ll n, idx = 0, val, rs; cin >> n; Node nd; cin >> nd.x >> nd.y; val = nd.x, nd.diff = nd.y - nd.x + 1, Score.push_back(nd); for (int i = 1; i < n; i++){ cin >> nd.x >> nd.y; nd.diff = nd.y - nd.x + 1; if (nd.x > val) idx++; Score.push_back(nd); } rs = idx; sort(all(Score), cmp); PriorityQueue pq; int lstidx = idx + 1; for (int i = 0; i < idx; i++){ pq.add(Score[i].diff); } while (val >= pq.top()){ if (!rs || pq.top() == -1) break; if (pq.top() <= val){ val -= pq.top(); pq.remove(); idx--; } while (lstidx < n && Score[lstidx].x > val){ pq.add(Score[lstidx].diff); lstidx++; idx++; } rs = min(rs, idx); } cout << rs + 1 << ln; return 0; }
// Return a list<Edge> containing the list of edges in the minimum spanning tree found by Kruskal's Algorithm list<Edge> KruskalMST::tree() { list<Edge> mst; PriorityQueue<Edge> p; Node selected; Edge selectedEdge; // Add each node of the graph to its own set list<Node> allNodes = graph.vertices(); for(list<Node>::iterator i=allNodes.begin(); i != allNodes.end(); ++i) makeSet(*i); // Insert all edges from the graph into priority queue for(list<Node>::iterator i=allNodes.begin(); i != allNodes.end(); ++i) { list<Node> iEdges = graph.neighbors((*i).getNodeNumber()); for(list<Node>::iterator j=iEdges.begin(); j != iEdges.end(); ++j) { Edge e((*i).getNodeNumber(),(*j).getNodeNumber(),(*j).getEdgeWeight()); p.insert(e); } } while(p.size() != 0) { selectedEdge = p.top(); // Remove the lower edge from the priority queue if (findSet(selectedEdge.getSrc()) != findSet(selectedEdge.getDst())) { mst.push_back(selectedEdge); // If src and dst are in different sets, then add this edge to mst combineSet(selectedEdge.getSrc(),selectedEdge.getDst()); // Combine both sets into one } } return mst; }
double skipToTs(double ts) { double ret = -1000000000.0; for(int i = 0; i < 100; i++){ // "tick" the video, filling up the frame queue tick(true); // throw away any frames below the requested time double curr = .0; while(frameQueue.GetContainer().size() > 0 && (curr = timeFromTs(frameQueue.GetContainer().at(0)->GetPts())) < ts){ ret = curr; frameQueue.GetContainer().erase(frameQueue.GetContainer().begin()); } // done if the frameQueue has a timestamp equal to or larger than the requested time if(frameQueue.size() > 0 && timeFromTs(frameQueue.top()->GetPts()) >= ts) break; } if(frameQueue.size() > 0){ // return the actual timestamp achieved ret = timeFromTs(frameQueue.GetContainer().at(0)->GetPts()); audioHandler->discardQueueUntilTs(ret); } return ret; }
// @snip <sh19910711/contest:setlib/disjoints_set.cpp> template <typename GraphType> const typename std::vector<typename GraphType::Edge> get_minimum_spanning_forest( const GraphType& G ) { typedef typename std::vector<typename GraphType::Edge> Edges; typedef typename GraphType::Edge GraphEdge; typedef typename GraphType::Edges GraphEdges; typedef std::priority_queue<GraphEdge, Edges, std::greater<GraphEdge> > PriorityQueue; typedef setlib::DisjointSets UnionFind; Edges res; PriorityQueue E; UnionFind uf(G.num_vertices); for ( int i = 0; i < G.num_vertices; ++ i ) { for ( typename GraphEdges::const_iterator it_i = G.vertex_edges[i].begin(); it_i != G.vertex_edges[i].end(); ++ it_i ) { const GraphEdge& e = **it_i; E.push(GraphEdge(e.from, e.to, e.weight)); } } while ( ! E.empty() ) { GraphEdge e = E.top(); E.pop(); if ( ! uf.same(e.from, e.to) ) { res.push_back(e); uf.merge(e.from, e.to); } } return res; }
void dumpContents( const string & msg, PriorityQueue & pq ) { cout << msg << ":" << endl; while( !pq.empty( ) ) { cout << pq.top( ) << endl; pq.pop( ); } }
int main(){ PriorityQueue<int> pq; for(int i=0;i<10;i++){ pq.push(i); } while(!pq.empty()){ cout<<pq.top()<<" "; pq.pop(); } }
FramePtr fetchFrame() { bool wasStepIntoQueue = stepIntoQueue; if(frameQueue.empty() && IsEof() && !reportedEof) { reportedEof = true; messageCallback(MEof, "eof"); } if(stepIntoQueue && !frameQueue.empty()) { stepIntoQueue = false; timeHandler->SetTime(timeFromTs(frameQueue.top()->GetPts()) + .001); audioHandler->discardQueueUntilTs(timeHandler->GetTime()); } double time = timeHandler->GetTime(); FramePtr newFrame = 0; // Throw away all old frames (timestamp older than now) except for the last // and set the pFrame pointer to that. int poppedFrames = 0; while(!frameQueue.empty() && timeFromTs(frameQueue.top()->GetPts()) < time) { newFrame = frameQueue.top(); frameQueue.pop(); poppedFrames++; } if(poppedFrames > 1){ FlogD("skipped " << poppedFrames - 1 << " frames"); } if(newFrame != 0 && (newFrame->GetPts() >= time || wasStepIntoQueue)) return newFrame; return 0; }
inline void inpainting_loop(VertexListGraph& g, InpaintingVisitorType vis, BoundaryStatusMap& boundaryStatusMap, PriorityQueue& boundaryNodeQueue, NearestNeighborFinder find_inpainting_source, PatchInpainter inpaint_patch) { typedef typename boost::graph_traits<VertexListGraph>::vertex_descriptor Vertex; typedef typename boost::graph_traits<VertexListGraph>::edge_descriptor Edge; typedef typename boost::property_traits<PositionMap>::value_type PositionValueType; // When this function is called, the priority-queue should already be filled // with all the hole-vertices (which should also have "Color::black()" color value). // So, the only thing this function does is run the inpainting loop. All of the // actual code is externalized in the functors and visitors (vis, find_inpainting_source, inpaint_patches, etc.). while(true) { // find the next target to in-paint: Vertex targetNode; do { if( boundaryNodeQueue.empty() ) { std::cout << "Queue is empty, exiting." << std::endl; return; //terminate if the queue is empty. } targetNode = boundaryNodeQueue.top(); boundaryNodeQueue.pop(); } while( get(boundaryStatusMap, targetNode) == false ); // Notify the visitor that we have a hole target center. vis.discover_vertex(targetNode, g); // next, we want to find a source patch-center that matches best to our target-patch: Vertex source_patch_center = find_inpainting_source(targetNode); vis.vertex_match_made(targetNode, source_patch_center, g); // finally, do the in-painting of the target patch from the source patch. // the inpaint_patch functor should take care of iterating through the vertices in both // patches and call "vis.paint_vertex(target, source, g)" on the individual vertices. inpaint_patch(targetNode, source_patch_center, g, vis); if(!vis.accept_painted_vertex(targetNode, g)) { throw std::runtime_error("Vertex was not painted successfully!"); } vis.finish_vertex(targetNode, g); } // end main iteration loop };
Node getNode(char name){ if (find(name)){ PriorityQueue tempQueue; while (top().name != name){ tempQueue.push(top()); pop(); } Node node = top(); while (!tempQueue.empty()){ push(tempQueue.top()); tempQueue.pop(); } return node; } }
// Return a list<char> containing the list of nodes in the shortest path between 'u' and 'w' list<char> ShortestPath::path(char u, char w) { // Initialize candidates list with all nodes list<char> candidates = graph.vertices(), desiredPath; list<NodeInfo> minPaths; PriorityQueue p; NodeInfo lastSelected, n; // Calculate shortest path from 'u' to 'w' (Dijkstra's Algorithm) candidates.remove(u); // Remove 'u' from candidates list lastSelected.nodeName = u; // Set 'u' as lastSelected lastSelected.minDist = 0; lastSelected.through = u; minPaths.push_back(lastSelected); // Add 'u' to minPath list while ((!candidates.empty()) && (lastSelected.nodeName !=w)) { // For each node in candidate list calculate the cost to reach that candidate through lastSelected for(list<char>::iterator i=candidates.begin(); i != candidates.end(); ++i) { n.nodeName=*i; n.minDist=lastSelected.minDist+graph.get_edge_value(lastSelected.nodeName,*i); n.through=lastSelected.nodeName; if (!p.contains(n)) // Add candidate to priority queue if doesn't exist p.insert(n); else if (p.isBetter(n)) // Update candidate minDist in priority queue if a better path was found p.chgPriority(n); } lastSelected = p.top(); // Select the candidate with minDist from priority queue p.minPriority(); // Remove it from the priority queue minPaths.push_back(lastSelected); // Add the candidate with min distance to minPath list candidates.remove(lastSelected.nodeName); // Remove it from candidates list } // Go backward from 'w' to 'u' adding nodes in that path to desiredPath list lastSelected=minPaths.back(); desiredPath.push_front(lastSelected.nodeName); while(lastSelected.nodeName!=u) { for(list<NodeInfo>::iterator i=minPaths.begin(); i != minPaths.end(); ++i) if ((*i).nodeName==lastSelected.through) { lastSelected=(*i); desiredPath.push_front(lastSelected.nodeName); } } return desiredPath; }
static bool A_star(DGR& dg, Weight& w, Digraph::Node s, Digraph::Node t, int k, DistMap& dist, PredMap& pred) { if(s == t) return false; typedef QNode Node; typedef std::vector<QNode> NodeCon; typedef std::priority_queue<Node,NodeCon> PriorityQueue; PriorityQueue pq; int cnt = 0; pred[s] = INVALID; pq.push(Node(s, INVALID, 0, dist[s])); while(!pq.empty()) { Node node = pq.top(); Digraph::Node u = node.u; pred[u] = node.parent; //cout<<"->pop:f("<<Digraph::id(u)<<")="<<node.g+p.h // <<"\tg("<<Digraph::id(u)<<")="<<node.g // <<"\th("<<Digraph::id(u)<<")="<<node.h // <<endl; pq.pop(); if(u == t) { //cout<<"---------------------"<<endl; cnt++; } if(cnt == k) { break; } for(typename DGR::OutArcIt e(dg,u);e!=INVALID;++e) { Digraph::Node v = dg.target(e); pred[v] = u; Node child_node(v, u, node.g + w[e], dist[v]); //cout<<"\t->push:f("<<Digraph::id(v)<<")="<<child_node.g+child_node.h //<<"\tg("<<Digraph::id(v)<<")="<<child_node.g //<<"\th("<<Digraph::id(v)<<")="<<child_node.h //<<endl; pq.push(child_node); } } return (cnt == k); }
// Return a list<Edge> containing the list of edges in the minimum spanning tree found by Prim's Algorithm list<Edge> PrimMST::tree() { list<Edge> mst; PriorityQueue<Edge> p; Node selected; Edge selectedEdge; // Create selectedNodes empty set // Create candidateNodes set containing all nodes list<Node> selectedNodes; list<Node> candidateNodes = graph.vertices(); while (!candidateNodes.empty()) { // Add first node from candidateNodes set to selectedNodes set and remove it from candidateNodes selected = candidateNodes.front(); selectedNodes.push_back(selected); candidateNodes.remove(selected); // Insert all edges from first node into priority queue list<Node> sEdges = graph.neighbors(selected.getNodeNumber()); for(list<Node>::iterator j=sEdges.begin(); j != sEdges.end(); ++j) { Edge e(selected.getNodeNumber(),(*j).getNodeNumber(),(*j).getEdgeWeight()); p.insert(e); } while(p.size() != 0) { selectedEdge = p.top(); // Remove the lower edge from the priority queue if ((isSrcInSet(selectedEdge,selectedNodes)) && (isDstInSet(selectedEdge,candidateNodes))) { mst.push_back(selectedEdge); // Add selected node to selectedNodes set and remove it from candidateNodes set selected = getNodeInSet(selectedEdge.getDst(),candidateNodes); selectedNodes.push_back(selected); candidateNodes.remove(selected); // Insert all edges from dst node into priority queue sEdges = graph.neighbors(selected.getNodeNumber()); for(list<Node>::iterator j=sEdges.begin(); j != sEdges.end(); ++j) { Edge e(selected.getNodeNumber(),(*j).getNodeNumber(),(*j).getEdgeWeight()); p.insert(e); } } } } return mst; }
void adjustTime(){ // Checks so that the current time doesn't diff too much from the decoded frames. // If it does the stream probably jumped ahead or back, so current time needs to // be adjusted accordingly. if(frameQueue.empty()) return; double time = timeHandler->GetTime(); double pts = timeFromTs(frameQueue.top()->GetPts()); // If the next frame is far into the future or the past, // set the time to now if(pts > time + 100.0 || pts < time - 100.0){ FlogD("adjusted time"); timeHandler->SetTime(pts); } }
inline void sweep(Range const& range, PriorityQueue& queue, InitializationVisitor& initialization_visitor, EventVisitor& event_visitor, InterruptPolicy const& interrupt_policy) { typedef typename PriorityQueue::value_type event_type; initialization_visitor.apply(range, queue, event_visitor); while (! queue.empty()) { event_type event = queue.top(); queue.pop(); event_visitor.apply(event, queue); if (interrupt_policy.enabled && interrupt_policy.apply(event)) { break; } } geofeatures_boost::ignore_unused(interrupt_policy); }
void myerase(Node val) { PriorityQueue <Node, std::vector<Node>, Compare> tmp; while (this->c.size() > 0) { auto first = this->c.begin(); if (first->getTab() == val.getTab()) { this->pop(); break; } tmp.push(*first); this->pop(); } while (tmp.size() > 0) { this->push(tmp.top()); tmp.pop(); } }
// DESC: Dijkstra's algorithm to find shortest distance from source to destination on a graph. // INPUT: Graph to expand on, Vertex to represent as the source. // OUTPUT: Linked list of the path LinkedListT* DijkstraDistances(Graph* graph, Vertex* source) { // form a cloud to every point. // Store this cloud in the PQueue. LinkedListT* verticies = graph->verticies(); PriorityQueue* pq = new PriorityQueue(); // loop through verticies for(int i=0; i<verticies->size(); i++) { Vertex* vv = (Vertex*)verticies->get(i); if(vv == source) { vv->distance = 0; // set vertex to zero if it is the source vertex. } else { vv->distance = 999999999; // set verticies to infinity to represent an unreachable location. } // insert into queue. pq->insert(vv->distance,vv); } // empty out the set while(!pq->empty()) { // remove the minimum distance from the set. (usually source vertex on start) Vertex* v = (Vertex*)pq->removeMin(); LinkedListT* vt = v->incidentEdges; // loop through incident Edges for(int i=0; i<vt->size(); i++) { Edge* e = (Edge*)vt->get(i); Vertex* v2 = e->opposite(v); int r = v->distance + e->data; // if the total range is less than v2's distance, then set it. if(r < v2->distance) { v2->distance = r; pq->replaceKey(pq->top(),(void*)v2,r); } } } }
void Prim::mst(int root,Color color){ Q.clear(); int size=G->V(); // number of vertices for(int i=0;i<size;i++){ dist[i]=1000.0; edges[i]=NO_EDGE; if(G->get_node_value(i)==color){ // only choose the same color //dist[i]=INF; // equal to infinite //cout<<"insert node!"<<i<<" and dist is "<<dist[i]<<endl; Q.Insert(Type_Queue_Element (i,dist[i])); // assign V[G] to Q } } dist[root]=0.0; if(!Q.contains(root)) cout<<"not include root !!"<<endl; else { Q.chgPrioirity(root,dist[root]); //dist[i] and priority value in priority queue must be synchronized edges[root]=ROOT_EDGE; while(!Q.empty()){ Type_Queue_Element currElement=Q.top(); Q.minPrioirty(); // remove from priority queue int currNode=currElement.first; if(edges[currNode]!=NO_EDGE){ dist[currNode]=currElement.second; vector<int> neibs=G->neighbors(currNode,color); for(unsigned int i=0;i<neibs.size();i++){ if(Q.contains(neibs[i]) && (G->get_edge_value(neibs[i],currNode)<dist[neibs[i]]) ){ edges[neibs[i]]=currNode; dist[neibs[i]]=G->get_edge_value(neibs[i],currNode); Q.chgPrioirity(neibs[i],dist[neibs[i]]); } } } } } }
void decreaseKey(char node, int newKey, char newPi){ cout << "decreaseKey(" << node << ", " << newKey << ", " << newPi << endl; if (find(node)){ cout << "found" << endl; PriorityQueue tempQueue; while (top().name != node){ cout << "popping out" << endl; tempQueue.push(top()); pop(); } Node node = top(); cout << "orig: " << node.name << ", " << node.pi << ", " << node.key << endl; pop(); node.key = newKey; node.pi = newPi; push(node); while (!tempQueue.empty()){ cout << "pushing back" << endl; push(tempQueue.top()); tempQueue.pop(); } } cout << "leaving" << endl; }
bool Hex<T>::shortest_path(T source, T target, player_t player) { PriorityQueue<T,T> priorityQueue; // Apart from board positions, we also add source and target in the priority queue. // source & target: These are virtual home and goal. //Initialize cost of vertices as infinite except the source vertex for (T vtx_i = 0; vtx_i != graph_.nVertex(); ++vtx_i) { vecVisited_[vtx_i] = false; if (vtx_i == source) { vecCost_[vtx_i] = 0; priorityQueue.insert_element(vtx_i,0); } else { vecCost_[vtx_i] = std::numeric_limits<T>::max(); if ( ( is_pos_on_board(vtx_i) && (board_.position_player(vtx_i) == player) ) || (vtx_i == target) ) { priorityQueue.insert_element(vtx_i,std::numeric_limits<T>::max()); } } } bool reachedTarget = false; while (!priorityQueue.empty()) { std::pair<T,T> topElem = priorityQueue.top(); T vtxTop = topElem.first; T costTop = topElem.second; vecVisited_[vtxTop] = true; priorityQueue.remove_element(vtxTop,costTop); if (costTop == std::numeric_limits<T>::max()) { break; // reaching here means path from source to target is not present } if (vtxTop == target) { reachedTarget = true; break; } std::vector<T> neighbors = graph_.neighbors(vtxTop); for (std::vector<T>::iterator it = neighbors.begin(); it != neighbors.end(); ++it) { if (vecVisited_[*it]) { continue; } // For a board position consider this neighbor only if the current player has placed // his/her hex on this position. if (is_pos_on_board(*it)) { if (board_.position_player(*it) != player) { continue; } } else if ((*it) != target) { continue; } T newCost = vecCost_[vtxTop] + 1; if (newCost < vecCost_[*it]) { priorityQueue.change_priority(*it,vecCost_[*it],newCost); vecCost_[*it] = newCost; } } } return reachedTarget; }
//- "k_nearest_neighbor" //- Find the K nearest neighbors to a point. //- //- Description: //- This algorithm is based on the best-first search. The goal of this //- algorithm is to minimize the number of nodes visited by using the //- distance to each subtree's bounding box to avoid visiting subtrees //- which could not possibly contain one of the k nearest objects. //- template <class Z> CubitStatus KDDTree<Z>::k_nearest_neighbor (CubitVector &q, int k, double &closest_dist, DLIList<Z> &nearest_neighbors, typename KDDTree<Z>::DistSqFunc dist_sq_point_data ) { //// Create the priority queues PriorityQueue<KDDTreeNode<Z>*> *queue = new PriorityQueue<KDDTreeNode<Z>*> (KDDTree<Z>::less_than_func); PriorityQueue<KDDTreeNode<Z>*> *queueTemp = new PriorityQueue<KDDTreeNode<Z>*> (KDDTree<Z>::less_than_func); KDDTreeNode<Z> *element = root; // push this node on the queue element->set_dist (min_dist_sq (q, element->safetyBox)); element->set_dist_data (DD_SAFETY); queue->push (element); // if the k closest nodes on the tree are not leaf-nodes, expand the closest // non-leaf node while ( !queue->empty() ) { element = queue->top(); queue->pop(); if (element->get_dist_data() == DD_LEAF) { // this node is a leaf, so it can be pushed onto the temporary queue queueTemp->push (element); } else { // one of the top k nodes is a non-leaf node, so expand it if (element->left) { element->left->set_dist (min_dist_sq (q, element->left->safetyBox)); element->left->set_dist_data (DD_SAFETY); queue->push (element->left); } if (element->right) { element->right->set_dist (min_dist_sq (q, element->right->safetyBox)); element->right->set_dist_data (DD_SAFETY); queue->push (element->right); } element->set_dist (dist_sq_point_data (q, element->data)); element->set_dist_data (DD_LEAF); queue->push (element); // take all the elements in the temporary queue and reinsert them into // the actual queue while ( !queueTemp->empty() ) { queue->push ( queueTemp->top() ); queueTemp->pop (); } } if (queueTemp->size() == k) { // success-- place the k nodes into the nearest_neighbors list element = queueTemp->top(); queueTemp->pop(); closest_dist = element->get_dist(); nearest_neighbors.append (element->data); while ( !queueTemp->empty() ) { nearest_neighbors.append ( queueTemp->top()->data ); queueTemp->pop(); } return CUBIT_SUCCESS; } } return CUBIT_FAILURE; }