数据结构：数组模拟堆

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

1. I x，插入一个数 x；
2. PM，输出当前集合中的最小值；
3. DM，删除当前集合中的最小值（数据保证此时的最小值唯一）；
4. D k，删除第 k 个插入的数；
5. C k x，修改第 k 个插入的数，将其变为 x；

/*
  数组模拟堆（heap）
  
  堆包含的基本操作：
  1.插入一个数
  2.求集合当中的最小值：heap[1]
  3.删除最小值
  4.删除任意一个元素
  5.修改任意一个元素（STL包含前三个）
  
  
  
  堆是一棵完全二叉树
  
  小根堆：每个父亲节点的值小于等于左右儿子节点的值，根节点就是整个树最小的值。
  
  用数组存储堆，下标1是根节点，2x 是左儿子，2x + 1 是右儿子（下标用1开始更方便）
  
  1. down操作：把变大的数或新插入的数向下移动，比较当前父亲和左右儿子节点，修改的点和当前三个点里面最小的点交换
  
  2. up操作：把变小的或新插入的数向上移动，把修改的点和它的父节点比较，比父节点小就交换
  
  down操作和up操作的时间复杂度都和树的深度有关，为log（n）;

*/

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

using namespace std;

const int N = 1e5 + 10;


int h[N], Size = 0;

// ph[N]：第k个插入的数的数组下标
// hp[N]：下标为k的点是第几个插入的
// 双向映射
int ph[N], hp[N];

void heap_swap(int a, int b)
{
    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 <= Size && h[u * 2] < h[t]) t = u * 2;
    
    // 右儿子节点存在
    if(u * 2 + 1 <= Size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
    
    if(t != u)
    {
        heap_swap(t, u);
        down(t);
    }
}

void up(int u)
{
    // 父亲节点存在
    while(u / 2 > 0 && h[u / 2] > h[u])
    {
        heap_swap(u, u /2);
        u /= 2;
    }
}

int main()
{
    // m:第几次插入
    int n, m = 0;
    scanf("%d", &n);
    
    while(n--)
    {
        char op[10];
        int k, x;
        
        scanf("%s", op);
        
        // strcmp:相等返回0
        if(!strcmp(op, "I"))
        {
            scanf("%d", &x);
            Size ++;
            m ++;
            ph[m] = Size, hp[Size] = m;
            h[Size] = x;
            up(Size);
        }
        else if(!strcmp(op, "PM"))
        {
            cout << h[1] << endl;
        }
        else if(!strcmp(op, "DM"))
        {
            heap_swap(1, Size);
            Size --;
            down(1);
        }
        else if(!strcmp(op, "D"))
        {
            scanf("%d", &k);
            
            // 交换的是下标
            k = ph[k];
            heap_swap(k, Size);
            Size --;
            
            // down和up只会执行一个
            down(k), up(k);
        }
        else
        {
            scanf("%d%d", &k, &x);
            k = ph[k];
            h[k] = x;
            down(k), up(k);
        }
    }
    
    return 0;
}