C++ priority_queue::top方法代码示例

// Ksruskal's main funtion
int TransportSystem(double& r_cost, double& rr_cost, int r, int n)
{		
	//int r_cost = 0, rr_cost = 0;
	int states = 1;
	InitSet(n); // initially all vertices in disjoint set

	while (!edgeList.empty()) {
		pair<double, ii> front = edgeList.top();
		edgeList.pop();

		if (!IsSameSet(front.second.first, front.second.second)) { // if no cycle, in the disjoint set
			//mst_cost += (-front.first);
			if (-front.first <= r)
				r_cost += (-front.first);
			else if (-front.first > r) {
				rr_cost += (-front.first);
				states++;
			}

			UnionSet(front.second.first, front.second.second);
		}
	}
	return states;
}

int main()
{
    int n,x=0,m;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&m);
		q.push(m);
	}
	int ans=0;
	for(int i=1;i<=n-1;i++)
	{ 
		int b,c;
		b=q.top();q.pop();
		c=q.top();q.pop();
		q.push(b+c);
		printf("%d ",b);
		printf("%d ",c);
		printf("%d\n",ans);
		ans+=b+c;
	}
	printf("%d",ans);
	return 0;
}

void sp(vector<int> & dist, adjType & graph, priority_queue< KeyValPair> & heap, set<int> &found, int maxDist) {

	// all nodes whithin maxDist of start are stored in distances along with their distances
	// dist has to be initialized to -1 and sizez of num vertices of the graph

	while (!heap.empty()) {
		KeyValPair top = heap.top();
		heap.pop();
		top.value = top.value * -1;
		if (dist[top.key] != -1) continue;
		found.insert(top.key);
		dist[top.key] = top.value;
		//cout << "marked " << top.key << " " << top.value << endl;

		for (adjList::iterator i = graph[top.key].begin(); i != graph[top.key].end(); i++) {
			int adjNext = i->first;
			int adjLen  = i->second;
			if ((dist[adjNext] == -1) && (top.value + adjLen <= maxDist)) {
				heap.push(KeyValPair(adjNext, -1 *(top.value + adjLen)));
			}
		}
	}
	return;
}

int main()
{
	int a,n,s,t1,t2;
	while(cin>>n)
	{
		if(n==0)break;
		for(int i = 0; i < n; i++)
		{
			cin>>a;
			q.push(a);
		}
		s = 0;
		while(q.size()>1)
		{
			t1 = q.top(); q.pop();
			t2 = q.top(); q.pop();
			s+=t1+t2;
			q.push(t1+t2);
		}
		cout<<s<<endl;
		q.pop();
	}
	return 0;
}

void dijkstra(int s) {
    for(int i = 0; i <= n; i++) d1[i] = d2[i] = inf;
    while(!pq.empty()) pq.pop();
    d1[s] = 0;
    pq.push(PII(0, s));
    while(!pq.empty()) {
        PII cur = pq.top();
        pq.pop();
        w = cur.first;
        v = cur.second;
        if(d2[v] < w) continue;
        for(int i = 0; i < e[v].size(); i++) {
            int dd = w + e[v][i].w;
            if(d1[e[v][i].v] > dd) {
                swap(d1[e[v][i].v], dd);
                pq.push(PII(d1[e[v][i].v], e[v][i].v));
            }
            if(d2[e[v][i].v] > dd && dd > d1[e[v][i].v]) {
                d2[e[v][i].v] = dd;
                pq.push(PII(d2[e[v][i].v], e[v][i].v));
            }
        }
    }
}

/*************************************************************************************************
函数说明：软中断激活
输入参数：swiId： 待激活软中断ID
输出参数：无
返回值  ：成功返回0， 其它情况返回-1
**************************************************************************************************/
int SwiActivate(unsigned int swiId)
{
	if (!swiMap.count(swiId))
		return -1;
	swiQueue.push(swiMap[swiId]);

	while (!swiQueue.empty())
	{
		Node tempNode = swiQueue.top();
		if (runningId != tempNode.swiId)
		{
			int oldRunningId = runningId;
			runningId = tempNode.swiId;
			tempNode.proc();
			runningId = oldRunningId;
			swiQueue.pop();
		}
		else
			break;

	}

	return 0;
}

void dijkstra(int s)
{
    while (!q.empty()) q.pop();
    memset(d,0x3f,sizeof d);

    d[s]=0;
    q.push((Heap_node){s,d[s]});

    while (!q.empty())
    {
        Heap_node x=q.top();q.pop();

        if (d[x.s]<x.d) continue;

        for (int e=fir[x.s];~e;e=nex[e])
        {
            if (d[v[e]]>d[x.s]+w[e])
            {
                d[v[e]]=d[x.s]+w[e];
                q.push((Heap_node){v[e],d[v[e]]});
            }
        }
    }
}

int prime(){
    int ans = 0;
    Node t;
    t.v = 1;
    t.w = 0;
    que.push(t);
    int nume = 0;
    while(!que.empty() && nume < m){
        t = que.top();
        que.pop();
        if(vis[t.v]) continue;
        ans += t.w;
        vis[t.v] = true;
        nume++;
        for(int i = head[t.v]; i != -1; i = edge[i].n)
            if(!vis[edge[i].v]){
                Node tt;
                tt.v = edge[i].v;
                tt.w = edge[i].w;
                que.push(tt);
            }
    }
    return ans;
}

long long minCost(vector <string> road, vector <int> altitude)
{
	memset(vis, 0, sizeof vis);
	int n = road.size();
	long long ans = INF;
	//for (int i=0; i<n; ++i) road[i][i] = 'Y';
	for (int j = 0; j < n; ++j) {
		int d = abs(altitude[j] - altitude[0]);
		state s = {0, j, d};
		pq.push(s);
	}
	while (!pq.empty()) {
		state cur = pq.top(); pq.pop();
		int pos = cur.pos;
		int alt = cur.alt;
		long long dist = cur.dist;
		//cout << pos << ' ' << alt << ' ' << dist << endl;
		if (vis[pos][alt]) continue;
		vis[pos][alt] = 1;		

		if (pos == n-1) { ans = dist; break; }
		
		for (int i = 0; i < n; ++i)
		for (int j = 0; j < n; ++j) 
		if (road[pos][i] == 'Y' && altitude[alt] >= altitude[j])
		{
			if (!vis[i][j]) {
				long long d = dist + abs(altitude[i] - altitude[j]);
				state ss = {i, j, d};
				pq.push(ss);
			}
		}
	}
	if (ans >= INF) return -1;
	else return ans;
}

int main() {
    scanf("%d %d", &v, &e);
    for (int i = 0; i < e; i++) {
        scanf("%d %d %d %d", &m, &n, &d, &s);
        roads[m].push_back(make_pair(n, d * 60.0 / s));
        roads[n].push_back(make_pair(m, d * 60.0 / s));
    }

    num[1] = 0;
    dist[1] = 0.0;
    q.push(make_tuple(0, 0, 1));
    for (int i = 1; i <= v; i++) { num[i] = e; dist[i] = 1e16; }
    
    double this_time, new_cost;
    int this_num, idx, new_idx;

    while (!q.empty()) {
        std::tie(this_time, this_num, idx) = q.top(); q.pop();
        this_time *= -1; this_num *= -1;
        for (auto a : roads[idx]) {
            std::tie(new_idx, new_cost) = a;
            double alt = this_time + new_cost;
            if (alt < dist[new_idx]) {
                dist[new_idx] = alt;
                num[new_idx] = this_num + 1;
                q.push(make_tuple(-alt, -num[new_idx], new_idx));
            } else if (alt == dist[new_idx] &&
                    this_num + 1 < num[new_idx]) {
                num[new_idx] = this_num + 1;
                q.push(make_tuple(-alt, -num[new_idx], new_idx));
            }
        }
    }

    printf("%d\n%d\n", num[v], (int)(round(dist[v] / 3)));    
}

int dijkastra()
{   
    int i,j,k,s,pos=-1;
   
   	for(i=1;i<=n;i++)vis[i]=0;
   
    while(!q.empty())
    {
    
    s=q.top().i;
    q.pop();
    
    
    for(i=0;i<v[s].size();i++)
    {
    if(vis[v[s][i].first])continue;
    if(dis[s]+v[s][i].second<dis[v[s][i].first])
    {
                                                dis[v[s][i].first]=dis[s]+v[s][i].second;
                                                q.push(vertex(v[s][i].first,dis[v[s][i].first]));
    }
    }
    vis[s]=1;
    }
    
    j=0;
	for(i=1;i<=n;i++)
	{  
	   if(dis[i]>j){j=dis[i];pos=i;}
	   

    }
	
	
	return j;
}

int main(){
	 node1.date = 4 ;
	 node2.date = 5 ;
	 node3.date = 4 ;
	 node1.num = 5 ;
	 node2.num = 4 ;
	 node3.num = 3 ;
	q.push(node1) ;
	q.push(node2) ;
	q.push(node3) ;
		node[50].num = 100 ;
	q.push(node[50]) ;

	while(!q.empty()){
		Node temp ;
		temp = q.top() ;
		q.pop() ;
		cout << temp.date << " " << temp.num << endl ;
	}
	return 0 ;
	
	
	
}

int bfs(point s, point t){
    s.v = 0;
    is[s.x][s.y] = true;
    if(s.x == t.x && s.y == t.y) return s.v;
    qu.push(s);
    while(!qu.empty()){
        s = qu.top();
        qu.pop();
        if(s.x == t.x && s.y == t.y) return s.v;
        for(int i = 0; i < 4; i++){
            point s1;
            int dx = s.x + dir[i][0];
            int dy = s.y + dir[i][1];
            if(dx >= 0 && dx < n && dy >= 0 && dy < m && !is[dx][dy] && ch[dx][dy] != 'S' && ch[dx][dy] != 'R'){
                is[dx][dy] = true;
                if(ch[dx][dy] == 'B') s1.v = s.v + 2;
                else s1.v = s.v + 1;
                s1.x = dx, s1.y = dy;
                qu.push(s1);
            }
        }
    }
    return -1;
}

int replacement(int n, int gondolaSeq[], int replacementSeq[]){
    int piv = 0, piv2 = n+1, piv3 = 0;
    for (int i=0; i<n; i++) {
        if(gondolaSeq[i] <= n){
            piv = gondolaSeq[i] - i - 1+ n;
            piv %= n;
        }
    }
    int newSeq[100005] = {};
    for (int i=0; i<n; i++) {
        newSeq[i] = gondolaSeq[(i + n - piv)%n];
        if(newSeq[i] > n) pq.push(pi(newSeq[i],i+1));
    }
    while (!pq.empty()) {
        pi x = pq.top();
        pq.pop();
        replacementSeq[piv3++] = x.second;
        for (int i=piv2; i<x.first; i++) {
            replacementSeq[piv3++] = i;
        }
        piv2 = x.first + 1;
    }
    return piv3;
}

int main(){
	
	int n, l;
	int lig[1000007];
	int v[1005] = {0};
	scanf("%d %d",&n,&l);

	for(int i = 0; i < l; i++)
		scanf("%d",&lig[i]);

	if(l < n){
		for(int i = 0; i < n; i++)
			printf("%d %d\n",i+1,i < l ? 1 : 0);
	}
	else{ 
		for(int i = 0; i < n; i++){
			pq.push(make_pair(-lig[i],-i));
			v[i]++;
		}

		for(int i = n; i < l; i++){
			pair<int, int> aux;
			aux = pq.top();
			pq.pop();
			pq.push(make_pair(-lig[i]+aux.first,aux.second));
			v[-aux.second]++;
		}

		for(int i = 0; i < n; i++)
			printf("%d %d\n",i+1,v[i]);
	}




}