模拟堆（映射关系）

模拟堆

维护一个集合，初始时集合为空，支持如下几种操作：

1. I x，插入一个数 x；
2. PM，输出当前集合中的最小值；
3. DM，删除当前集合中的最小值（数据保证此时的最小值唯一）；
4. D k，删除第 k个插入的数；
5. C k x，修改第 k个插入的数，将其变为 x；
   现在要进行 N次操作，对于所有第 2个操作，输出当前集合的最小值。
   输入格式
   第一行包含整数 N。
   接下来 N行，每行包含一个操作指令，操作指令为 I x，PM，DM，D k 或 C k x 中的一种。
   输出格式
   对于每个输出指令 PM，输出一个结果，表示当前集合中的最小值。
   每个结果占一行。
   数据范围
   1≤N≤105
   −109≤x≤109
   数据保证合法。
   输入样例：
   8
   I -10
   PM
   I -10
   D 1
   C 2 8
   I 6
   PM
   DM
   输出样例：
   -10
   6

#include<iostream>
#include<algorithm>
#include<string.h>

using namespace std;

const int N = 1e5+10;

int n;
int h[N],ph[N],hp[N],s;//既需要求插入，又要从插入后的点寻找插入的值

void heap_swap(int a,int b){//特有的交换，映射关系的记录，删除或者修改第k个所特有的，重点
    swap(ph[hp[a]],ph[hp[b]]);
    swap(hp[a],hp[b]);
    swap(h[a],h[b]);
}

void down(int u){
    int t=u;
    if(u*2<=s&&h[u*2]<h[t]) t=u*2;
    if(u*2+1<=s&&h[u*2+1]<h[t]) t=u*2+1;
    if(u!=t){
        heap_swap(u,t);
        down(t);
    }
}
void up(int u){
    while(u/2&&h[u/2]>h[u]){
        heap_swap(u/2,u);
        u/=2;
    }
}

int main(){
    scanf("%d",&n);
    int m=0;
    while(n--){
        char op[10];
        int k,x;
        scanf("%s",op);
        if(!strcmp(op,"I")){
            scanf("%d",&x);
            s++;
            m++;
            ph[m]=s;
            hp[s]=m;
            h[s]=x;
            up(s);
        }
        else if(!strcmp(op,"PM")) printf("%d\n",h[1]);
        else if(!strcmp(op,"DM")){
            heap_swap(1,s);
            s--;
            down(1);
        }
        else if(!strcmp(op,"D")){
            scanf("%d",&k);
            k=ph[k];
            heap_swap(k,s);
            s--;
            down(k),up(k);
        }
        else{
            scanf("%d%d",&k,&x);
            k = ph[k];
            h[k]=x;
            down(k),up(k);
        }
    }
    return 0;
}