C++ PQ::push方法代码示例

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 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];
}

// 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;
}

// 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;
}

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();
  }

}

VectorXf GeodesicDistance::compute(int nd) const {
	PQ q;
	q.push( Node( nd, 0 ) );
	VectorXf d = 1e10*VectorXf::Ones( N_ );
	updatePQ( d, q );
	return d;
}

int main(){
    int n,m; cin>>n>>m;
    while(m--){
        int u,v; ll c; cin>>u>>v>>c;
        pq.push({c,pii(u,v)});
        E.eb(c,pii(u,v));
    }
    djs.init(1006);
    int pointsssss=1;
    ll firstttttt=0;
    while(pq.size()){
        if(!djs.C(pq.top().Y.X,pq.top().Y.Y)){
            G[pq.top().Y.X].eb(pq.top().Y.Y,pq.top().X);
            G[pq.top().Y.Y].eb(pq.top().Y.X,pq.top().X);
            ++pointsssss;
            firstttttt+=pq.top().X;
            djs.U(pq.top().Y.X,pq.top().Y.Y);
        } pq.pop();
    } if(pointsssss<n)return cout<<"-1 -1"<<endl,0;
    if(E.size()==n-1)return cout<<firstttttt<<" -1"<<endl,0;
    dfs(1,1,1);
    PDE1(firstttttt);
    ll diffffffff=1000000000000000000ll;
    for(auto i:E){
        if(p[0][i.Y.X]==i.Y.Y || p[0][i.Y.Y]==i.Y.X)continue;
        PDE1(i);
        diffffffff=min(diffffffff,i.X-lca(i.Y.X,i.Y.Y));
    } cout<<firstttttt<<" "<<firstttttt+diffffffff<<endl;
}

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;
}

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;
}

  /*! 
    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 test2() {
  PQ p;
  for (int i = 0;i < 10;i++) {
    p.push(10-i);
  }

  while (p.empty() == false) {
    cout << p.top() << endl;
    p.pop();
  }
}

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 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;
}

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;
            
        }
    }
}

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;
}