VectorXf GeodesicDistance::compute(int nd) const { PQ q; q.push( Node( nd, 0 ) ); VectorXf d = 1e10*VectorXf::Ones( N_ ); updatePQ( d, q ); return d; }
void benchOpsThread(bench_ops_thread_arg_t * arg) { wbmm_thread_init(arg->tid); uint32_t seed1 = arg->tid; uint32_t seed2 = seed1 + 1; uint64_t ops = 0; PQ * set = (PQ *)arg->set; while (!bench_begin); while (!bench_stop) { int op = rand_r_32(&seed1) % 100; int key = rand_r_32(&seed2) % KEY_RANGE; if (op < 50) { set->add(key); } else { key = set->remove(); } for (int i = 0; i < DELAY; i++) spin64(); ops++; } arg->ops = ops; }
int dijdij(int st,int ed){ v[0].reset(); v[1].reset(); for(int i=0;i<111;++i)d[i].clear(); d[st].pb(0); PQ<pii,vector<pii>,greater<pii>> pq; pq.push({0,st}); while(pq.size()){ while(pq.size() && v[1][pq.top().Y])pq.pop(); if(pq.empty())break; pii now=pq.top(); pq.pop(); int stp=v[0][now.Y]?1:0; PDE3(now,stp,pq); v[stp][now.Y]=1; for(pii e:G[now.Y]){ d[e.X].pb(now.X+e.Y); sort(d[e.X].begin(),d[e.X].end()); d[e.X].resize(unique(d[e.X].begin(),d[e.X].end())-d[e.X].begin()); if(d[e.X].size()>2u){ sort(d[e.X].begin(),d[e.X].end()); d[e.X].pop_back(); } if(now.X+e.Y<=d[e.X].back()){ pq.push({now.X+e.Y,e.X}); } } } if(d[ed].size()<2u)return -1; else return d[ed][1]; }
GeodesicDistance& GeodesicDistance::update( const VectorXf &new_min ) { PQ q; for( int i=0; i<N_; i++ ) if( new_min[i] < d_[i] ) q.push( Node( i,new_min[i] ) ); updatePQ( d_, q ); return *this; }
/*! Transforms the queue into a vector of indeces to points and returns it \param pl Vector which will hold the answer after function completes */ void answer(vector<long unsigned int>& pl) { pl.resize(K); for(int i=pl.size()-1;i >= 0;--i) { pl[i] = pq.top().second; pq.pop(); } };
VectorXf GeodesicDistance::compute(const VectorXf &start) const { PQ q; for( int i=0; i<N_; i++ ) if( start[i] < 1e5 ) q.push( Node( i, start[i] ) ); VectorXf d = 1e10*VectorXf::Ones( N_ ); updatePQ( d, q ); return d; }
/*! Transforms the queue into a vector of indeces to points and a vector of squared distances \param pl Vector which holds the point indeces after function completes \param pd Vector which holds the squared distances from query point */ void answer(vector<long unsigned int>& pl, vector<double> &pd) { pl.resize(K); pd.resize(K); for(int i=pl.size()-1;i >= 0; --i) { pl[i] = pq.top().second; pd[i] = pq.top().first; pq.pop(); } }
void test2() { PQ p; for (int i = 0;i < 10;i++) { p.push(10-i); } while (p.empty() == false) { cout << p.top() << endl; p.pop(); } }
static bool sanityCheck() { PQ set; uint32_t seed = 0; for (uint32_t i = 0; i < INIT_SIZE; i++) { int key = rand_r_32(&seed) % KEY_RANGE; set.add(key); } bench_begin = false; bench_stop = false; thread * thrs[NUM_THREADS]; sanity_thread_arg_t args[NUM_THREADS]; for (uint32_t j = 0; j < NUM_THREADS; j++) { sanity_thread_arg_t & arg = args[j]; arg.tid = j + 1; arg.set = &set; arg.ops = 0; thrs[j] = new thread(sanityThread<PQ>, &arg); } // broadcast begin signal bench_begin = true; sleep(DURATION); bench_stop = true; for (uint32_t j = 0; j < NUM_THREADS; j++) thrs[j]->join(); uint32_t old = 0; for (uint32_t i = 0; i < INIT_SIZE; i++) { uint32_t num = set.remove(); if (old > num) { cout << "error: heap invariant violated: " << "prev = " << old << " " << "curr = " << num << endl; return false; } if (num == PQ_VAL_MAX) { cout << "error: missing element(not linearizable)" << endl; return false; } old = num; } uint32_t num = set.remove(); if (num != PQ_VAL_MAX) { cout << "error: extra element(not linearizable)" << endl; return false; } cout << "Sanity check: okay." << endl; return true; }
int main(){ // freopen("in","r",stdin); // freopen("out","w",stdout); int ks=0,n,m;while(rit(n,m),n){ while(m--){ int a,b,l;rit(a,b,l); G[a].pb({b,l}); G[b].pb({a,l}); } pq.push({1,0}); while(pq.size()){ while(v[pq.top().X])pq.pop(); v[pq.top().X]=1; } } }
void pq_delete_min(PQ pq, void *retval) { int floater; /* previous loser floating down */ int small_child; /* smaller child of floater */ assert(!pq_is_empty(pq)); /* first copy out the winner */ memcpy(retval, REF(pq, 0), pq->element_length); --(pq->n); if(pq_is_empty(pq)) { /* pq empty, nothing to do */ return; } /* else */ memcpy(REF(pq, 0), REF(pq, pq->n), pq->element_length); floater = 0; for(;;) { /* find smaller child of floater */ if(Child(floater, 0) >= pq->n) { return; /* no children, bail out */ } else if(Child(floater, 1) >= pq->n) { small_child = Child(floater, 0); } else if(pq->compare(REF(pq, Child(floater, 0)), REF(pq, Child(floater, 1))) < 0) { small_child = Child(floater, 0); } else { small_child = Child(floater, 1); } /* is floater <= small_child? */ if(pq->compare(REF(pq, floater), REF(pq, small_child)) <= 0) { /* yes, we are done */ return; } else { /* no, swap and continue floating down */ pq_swap(pq, floater, small_child); floater = small_child; } } }
/*! Updates the queue with the given distance and point \param dist Distance of point to be added \param p index of point to be added \return True if a point was added to the queue */ bool update(double dist, long int p) { if(size() < K) { q_intelement tq(dist, p); pq.push(tq); return true; } else if(topdist() > dist) { pq.pop(); q_intelement tq(dist, p); pq.push(tq); return true; } return false; }
void testHeap ( int n ) { T* A = new T[2*n/3]; //创建容量为2*n/3的数组,并 for ( int i = 0; i < 2 * n / 3; i++ ) A[i] = dice ( ( T ) 3 * n ); //在其中随机生成2*n/3个词条 /*DSA*/printf ( "%d random keys created:\n", 2 * n / 3 ); /*DSA*/for ( int i = 0; i < 2 * n / 3; i++ ) print ( A[i] ); printf ( "\n" ); PQ heap ( A + n / 6, n / 3 ); //批量建堆(PQ_ComplHeap实现了Robert Floyd算法) delete [] A; /*DSA*/system("cls"); print ( heap ); Sleep(100); while ( heap.size() < n ) { //随机测试 if ( dice ( 100 ) < 70 ) { //70%概率插入新词条 T e = dice ( ( T ) 3 * n ); /*DSA*/printf ( "Inserting" ); print ( e ); printf ( " ...\n" ); heap.insert ( e ); /*DSA*/printf ( "Insertion done\n" ); } else { //30%概率摘除最大词条 if ( !heap.empty() ) { /*DSA*/printf ( "Deleting max ...\n" ); T e = heap.delMax();/*DSA*/printf ( "Deletion done with" ); print ( e ); printf ( "\n" ); } } /*DSA*/system("cls"); print ( heap ); Sleep(100); } while ( !heap.empty() ) { //清空 T e = heap.delMax();/*DSA*/printf ( "Deletion done with" ); print ( e ); printf ( "\n" ); /*DSA*/system("cls"); print ( heap ); Sleep(100); } }
static void runBench() { PQ set; uint32_t seed = 0; for (uint32_t i = 0; i < INIT_SIZE; i++) { int key = rand_r_32(&seed) % KEY_RANGE; set.add(key); } bench_begin = false; bench_stop = false; thread * thrs[NUM_THREADS]; bench_ops_thread_arg_t args[NUM_THREADS]; for (uint32_t j = 0; j < NUM_THREADS; j++) { bench_ops_thread_arg_t & arg = args[j]; arg.tid = j + 1; arg.set = &set; arg.ops = 0; thrs[j] = new thread(benchOpsThread<PQ>, &arg); } // broadcast begin signal bench_begin = true; sleep(DURATION); bench_stop = true; for (uint32_t j = 0; j < NUM_THREADS; j++) thrs[j]->join(); uint64_t totalOps = 0; for (uint32_t j = 0; j < NUM_THREADS; j++) { totalOps += args[j].ops; } cout << ("Throughput(ops/ms): ") << std::setprecision(6) << (double)totalOps / DURATION / 1000 << endl; }
/** *Requires that all Tree Nodes representing Active Characters have been created *And Enqueued into the Priorty Queue *Generates a huffman tree by combining the nodes in th PQ *the root of the tree is at the head of the priorty queue */ void Huffman:: HuffHuff() //now it creates the huffman tree { if(!(q->getSize1())) //single element q->enq(mTreeNodes(q->deq(),NULL)); while(q->getSize1()) { q->enq(mTreeNodes(q->deq(),q->deq())); } cout<<"\n\n\t\tLegend Tree along with char at end\n"<<endl; q->getHead()->displayTree(); system("pause"); }
//Insert limit elements of the file fin into heap. void insertNext(PQ & pq, ifstream & fin, int limit = 0) { if (limit == 0) limit = numeric_limits<int>::max(); string word; int ct; while (!fin.eof() && pq.size < limit){ fin >> word >> ct; pq.insert(ItemType(word, ct)); } }
void sanityThread(sanity_thread_arg_t * arg) { wbmm_thread_init(arg->tid); uint32_t seed1 = arg->tid; uint32_t seed2 = seed1 + 1; uint64_t ops = 0; PQ * set = (PQ *)arg->set; while (!bench_begin); while (!bench_stop) { int key = rand_r_32(&seed2) % KEY_RANGE; set->add(key); key = set->remove(); ops++; } arg->ops = ops; }
int main() { int n, m; scanf("%d %d", &n, &m); vector<vector<pii>> edges(n); while(m--) { int u, v, w; scanf("%d %d %d", &u, &v, &w); edges[u].push_back({w, v}); edges[v].push_back({w, u}); } PQ pq; pq.push({0,0}); while(!pq.empty()) { int dist = pq.top().first; int curr = pq.top().second; pq.pop(); if (vis[curr] != false) continue; vis[curr] = true; /* * curr visited in "shortest path" order here */ for(pii it : edges[curr]) { int ndist = it.first + dist; int next = it.second; pq.push({ndist, next}); } } return 0; }
int dijkstra(int start ,int goal ,int maxRank) { memset(dis , 0x7F ,sizeof(dis)); memset(apr , 0 ,sizeof(apr)); dis [start] = 0; que . size =0; que . push(start); while(!que . empty()) { PQNode t; bool notGet = true; while(!que . empty()) { t = que.top(); que.pop(); if(!apr[t . no]) { notGet = false; break; } } if(notGet)break; for(Node *p = adj[t . no];p ; p=p->next) { if( rank [p->y] > maxRank) continue; if( rank [p->y] < maxRank - limRank) continue; if(dis[p->y] > dis[t .no] + p->w) { dis[p->y] = dis[t .no] + p->w; que .push(p->y); } } apr [t. no] = true; } if( !apr[goal] ) return -1; return dis [goal]; }
bool sanityCheckSequential() { const int max = 10000; std::priority_queue<int32_t, vector<int32_t>, pqcompare> contrast; PQ m; uint32_t seed = 0; for (int i = 0; i < max; i++) { int32_t temp = rand_r_32(&seed) % KEY_RANGE; contrast.push(temp); m.add(temp); } for (int i = 0; i < max - 1; i++) { uint32_t r1 = m.remove(); uint32_t r2 = contrast.empty() ? PQ_VAL_MAX : contrast.top(); if (!contrast.empty()) contrast.pop(); if (r1 != r2) { cout << "different element at index " << i << ":" << r1 << " " << r2 << endl; return false; } } cout << "Sanity check: okay." << endl; return true; }
void test1() { PQ p; p.push(1); p.push(2); p.push(3); p.push(4); p.push(5); while (p.empty() == false) { cout << p.top() << endl; p.pop(); } }
void pq_sanity_check(PQ pq) { int i; int j; assert(pq->n >= 0); assert(pq->n <= pq->size); for(i = 0; i < pq->n; i++) { for(j = 0; j < NUM_CHILDREN; j++) { if(Child(i, j) < pq->n) { assert(pq->compare(REF(pq, i), REF(pq, Child(i, j))) <= 0); } } } }
// find top-k CC using boost graph representation PQ find_top_CC(DeterministicGraph& PW, int k) { typename graph_traits <DeterministicGraph>::out_edge_iterator out1, out2; PQ pq; // priority queue for top-k CC int V = num_vertices(PW); bool *explored = new bool[V+1]; for (int i = 0; i < V; ++i) explored[i] = false; int cc_number = 0; int unit_sized = 0; for (int i = 0; i < V; ++i) { if (!explored[i]) { // perform BFS for vertex i vector<int> CC; CC.push_back(i); explored[i] = true; vector<int>::size_type ix = 0; while (ix < CC.size()) { Vertex u = vertex(CC[ix], PW); for (tie(out1, out2) = out_edges(u, PW); out1 != out2; ++out1) { Vertex v = target(*out1, PW); if (!explored[v]) { CC.push_back(v); explored[v] = true; } } ix++; } // if (CC.size() > 5) // cout << cc_number << ": " << CC.size() << endl; if (CC.size() == 1) { unit_sized++; } cc_number++; // maintain CC priority queue int pq_size = pq.size(); if (pq_size == k) { vector<int> top = pq.top(); if (top.size() < CC.size()) { pq.pop(); pq.push(CC); } } else pq.push(CC); } } // cout << "Total CCs: " << cc_number << endl; // cout << "Unit CCs: " << unit_sized << endl; return pq; }
int main(){ while(scanf("%d%d",&n,&m)!=EOF,n){ init(); for(int i=0,a,b,p,t;i<m;i++){ a=rit(),b=rit(),p=rit(),t=rit(); g[a][b]={t,p}; } nb=rit(),ne=rit(); rT(STst),rT(STed); ts=getT(STst);te=getT(STed); PQ<_pq,vector<_pq>,greater<_pq>> pq; pq.push({nb,ts}); for(int _i=0;_i<n;++_i){ while(S(pq)&&v[pq.top().pt]){ pq.pop(); } if(S(pq)==0)break; v[pq.top().pt]=1; d[pq.top().pt]=pq.top().tm; int np=pq.top().pt,nt=pq.top().tm; for(int i=1;i<=n;++i){ // waiting time if(g[np][i].lo!=0 && d[i]>d[np]+g[np][i].lo+(g[np][i].ev-(d[np]%g[np][i].ev)%g[np][i].ev)){ d[i]=d[np]+g[np][i].lo+(g[np][i].ev-(d[np]%g[np][i].ev)%g[np][i].ev); pq.push({i,d[np]+g[np][i].lo+(g[np][i].ev-(d[np]%g[np][i].ev)%g[np][i].ev)}); } } } cout<<ts<<" "<<te<<endl; if(d[ne]==0x7f7f7f7f){ printf("No way\n"); continue; } else{ printf("--%d--\n",d[ne]); } } }
int dijkstra() { REP(i,n) REP(j,c+1) d[i][j] = INF, visited[i][j] = false; d[s][0] = 0; PQ pq; pq.push(State(s, 0, 0)); while(!pq.empty()) { State u = pq.top(); pq.pop(); if(u.node == e and u.fuel == 0) return u.cost; if(visited[u.node][u.fuel]) continue; visited[u.node][u.fuel] = true; /* // Create other states, when I just buy fuel int cost = u.cost; // current cost of fuel for(int f = u.fuel+1; f <= c; f++) { // try to fill until reach capacity c cost += prices[u.node]; int& bcost = d[u.node][f]; if(bcost > cost) { bcost = cost; pq.push(State(u.node, f, cost)); } }*/ FOREACH(el, g[u.node]) { if(el->second <= u.fuel) { int nfuel = u.fuel - el->second; if(u.cost < d[el->first][nfuel]) { d[el->first][nfuel] = u.cost; pq.push(State(el->first, nfuel, u.cost)); } } else if(u.fuel < c) { int cost = u.cost + prices[u.node]; int& bcost = d[u.node][u.fuel+1]; if(bcost > cost) { bcost = cost; pq.push(State(u.node, u.fuel+1, cost)); } } } } return INF; }
int main(){ ll n,r,avg; cin>>n>>r>>avg; ll totgn=0,need=n*avg; for(int i=0;i<n;++i)cin>>a[i]>>b[i],totgn+=a[i],pq.push({b[i],r-a[i]}); ll ans=0; while(totgn<need){ // PDE2(pq.top().es,pq.top().lft); if(pq.top().lft>=need-totgn){ ans+=pq.top().es*(need-totgn); break; } ans+=pq.top().es*pq.top().lft; totgn+=pq.top().lft; pq.pop(); } cout<<ans<<endl; }
// find top-k CCs using vectors graph representation PQ find_top_CC2(vector<vector<int> >& PW, int V, int k) { PQ pq; // priority queue for top-k CC map<int, bool> explored; for (int i = 0; i < V; ++i) explored[i] = false; int cc_number = 0; int unit_sized = 0; for (int i = 0; i < V; ++i) { if (!explored[i]) { // perform BFS for vertex i vector<int> CC; CC.push_back(i); explored[i] = true; vector<int>::size_type ix = 0; while (ix < CC.size()) { int pw_size = PW[CC[ix]].size(); for (int j = 0; j < pw_size; ++j) { int v = PW[CC[ix]][j]; if (!explored[v]) { CC.push_back(v); explored[v] = true; } } ix++; } // if (CC.size() > 5) // cout << cc_number << ": " << CC.size() << endl; if (CC.size() == 1) { unit_sized++; } cc_number++; // maintain CC priority queue int pq_size = pq.size(); if (pq_size == k) { vector<int> top = pq.top(); if (top.size() < CC.size()) { pq.pop(); pq.push(CC); } } else pq.push(CC); } } // cout << "Total CCs: " << cc_number << endl; // cout << "Unit CCs: " << unit_sized << endl; return pq; }
int main() { int numbers; int num; PQ myPQ; int sum; int totalCost; while (scanf("%d", &numbers) && numbers != 0) { totalCost = 0; for (int i = 0; i < numbers; i++) { scanf("%d", &num); myPQ.push(num); } while (true) { sum = myPQ.top(); myPQ.pop(); sum += myPQ.top(); myPQ.pop(); totalCost += sum; if (!myPQ.empty()) myPQ.push(sum); else break; } printf("%d\n", totalCost); } return 0; }
void pq_insert(PQ pq, const void *elt) { int floater; /* new element */ while(pq->n + 1 > pq->size) { pq->size *= 2; pq->data = realloc(pq->data, pq->element_length * pq->size); assert(pq->data); } /* copy the new element in */ floater = pq->n++; memcpy(REF(pq, floater), elt, pq->element_length); /* float it up until it is at the top */ /* or it is no smaller than its parent */ while(floater > 0 && pq->compare(REF(pq, floater), REF(pq, Parent(floater))) <= 0) { /* it's smaller than its parent */ pq_swap(pq, floater, Parent(floater)); floater = Parent(floater); } }
void dfs(int rt, int fa) { vis[rt] = true; if (adj[rt].size() == 1 && adj[rt][0] == fa) {f[rt].pb(v[rt]); return;} PQ q; q.push(v[rt]); for (int i=0; i<adj[rt].size(); i++) { int id = adj[rt][i]; if (!vis[id] && id != fa) {dfs(id, rt); for (int j=0; j<f[id].size(); j++) q.push(f[id][j]);} } int cnt = 0; while (!q.empty() && cnt < 3) { f[rt].pb(q.top()); q.pop(); cnt++; } sort(f[rt].begin(), f[rt].end(), greater<int>()); return ; }