一维数组模拟堆

1.

/如何手写一个堆？完全二叉树 5个操作
//1. 插入一个数         heap[ ++ size] = x; up(size);
//2. 求集合中的最小值   heap[1]
//3. 删除最小值         heap[1] = heap[size]; size -- ;down(1);
//4. 删除任意一个元素   heap[k] = heap[size]; size -- ;up(k); down(k);
//5. 修改任意一个元素   heap[k] = x; up(k); down(k);
#include <iostream>

using namespace std;

int const N = 100010;

//h[i] 表示第i个结点存储的值，i从1开始，2*i是左子节点，2*i + 1是右子节点
//size 既表示堆里存储的元素个数，又表示最后一个结点的下标
int h[N], siz; //堆有两个变量h[N]，size; 怎么这里的size和文件里有冲突，只能改成siz了

void down(int u)
{
    int t = u;//t存储三个结点中存在的最小的结点的下标，初始化为当前结点u
    if (u * 2 <= siz && h[u * 2] < h[t]) t = u * 2; // 左子节点存在并且小于当前结点，更新t的下标
    if (u * 2 + 1 <= siz && h[u * 2 + 1] < h[t]) t = u * 2 + 1;//右子节点存在并且小于当前结点，更新t的下标
    if (t != u)//如果t==u意味着不用变动，u就是三个结点中拥有最小值的结点下标，否则交换数值
    {
        swap(h[t], h[u]);
        down(t); //交换数值后，t这个结点存储原本u的值，u存储存储t的值（三个数中的最小值）。u不用调整了，但t情况不明，可能需要调整。直到它比左右子节点都小
    }
}

int main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i ++ ) scanf("%d", &h[i]); 
    siz = n; //初始化size,表示堆里有n 个元素

    for (int i = n / 2; i; i --) down(i); //把堆初始化成小根堆，从二叉树的倒数第二行开始，把数字大的下沉

    while (m -- )
    {
        printf("%d ", h[1]);
        h[1] = h[siz];
        siz --;
        down(1);
    }

    return 0;
}

 2.acwing 839

#include<bits/stdc++.h>
using namespace std;

const int N = 100010;
int n,m;
int h[N],siz; //模拟堆以及堆中有多少个元素
int ph[N],hp[N]; //第k个插入的点是哪个点(下标); 堆里面某个点是哪个插入的点
//ph从下标映射到堆里面去 ，hp从堆里映射到下标 

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; //t来表示三个点中的最小值的编号
    if(u * 2 <= siz && h[u * 2] < h[t]) t = u * 2; //左儿子存在且左儿子小于t ，t等于左儿子
    if(u * 2 + 1 <= siz && 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 > 0 && h[u / 2] > h[u])
    {
        heap_swap(u / 2,u);
        u /= 2;
    }
}

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

 3.合并果子P1090 [NOIP2004 提高组] 合并果子 / [USACO06NOV] Fence Repair G - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

 

#include<bits/stdc++.h>
using namespace std;
const int maxn=10000+10;
int n,heap[maxn],siz = 0;
void up(int u) //向上修复小根堆的过程
{
    if( u > 1 &&h[u / 2] > h[u])
    {
        swap(h[u],h[u / 2]);
        u /= 2;
    }
    //cout << " " << u;
    
}

void insert(int x) //二叉堆插入，新元素放在堆底，向上调整
{
  heap[++siz] = x;
  up(siz);
}
void down(int u) //二叉小根堆向下调整
{
  int t = u * 2;
  while(t <= siz)
  { //下面这句话是从左右儿子中选一个更小的做交换
    if(t < siz && heap[t + 1] < heap[t]) t ++; 
    if(heap[t] < heap[u])
    {
      swap(heap[t],heap[u]);
      u = t; 
      t = u * 2;
    }
    else break;
  }
}
void extract() //二叉堆删除堆顶
{
  heap[1]=heap[siz --]; //将堆底移至堆顶，向下调整
  down(1);
}

int gettop() //返回堆顶的值
{
  return heap[1];
}
int main()
{
  cin>>n;
  for(int i=1; i<=n; i++)
  {
     
    cin >> heap[i]; 
  }
  siz = n;
  for(int i = n / 2;i;i --) down(i);  //建立二叉堆
  
  long long ans = 0; //其实这里不会越界，但好像原题数据是3万
  while(siz >= 2) //如果还可合并
  {
    int top1 = gettop(); //取出堆顶（堆中最小值）后删除堆顶
    extract();
    int top2 = gettop(); //同上
    extract();
    ans+=(top1+top2);
    insert(top1+top2); //将两数之和加入二叉堆，重复运算
  }
  cout<<ans<<endl;
  return 0;
} 

 4.P1878 舞蹈课 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

用结构体堆来维护 差值的最小值

每次弹出差值的最小值，并且作上标记，在下一次循环的时候删掉，更新堆顶

注意此题两个相邻的异性可以用异或的性质去简化代码，当我们重连 删除之后的链表（堆）的时候

，我们需要两个数组来存之前 两个堆顶端点的左右值，然后删除后让这两个值左右相连。

#include<bits/stdc++.h>
using namespace std;

const int N = 2e5 + 10;

struct node
{
    int l,r;
    int v;
    bool operator<(const node &x) const {
    if(x.v == v) return x.l < l;
    return x.v < v;
    }
};
priority_queue<node> q;

int n;
char ch; //字符
bool bg[N]; //用来判断字符串数组是否为异性，是为异性就可以入堆
int a[N]; 
bool is[N]; //标记是否出现过
int l[N],r[N]; //表示两个端点的左右元素
vector<node> ans;

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i ++ ) cin >> ch,bg[i] = (ch == 'B' ? 1 : 0);
    for (int i = 1; i <= n; i ++ ) cin >> a[i];
    for (int i = 1; i <= n; i ++ ) l[i] = i - 1,r[i] = i + 1;
    
    is[0] = is[n + 1] = 1;
    for (int i = 2; i <= n; i ++ ) //如果相邻为异性，丢到堆中，从小到大进行排序
    if(bg[i] ^ bg[i - 1]) q.push({i - 1,i,abs(a[i - 1] - a[i])});
    
    while(!q.empty())
    { //如果堆顶的元素两个端点之前出现过(已经被标记了)，那么没用直接删掉
        while(!q.empty() && (is[q.top().l] || is[q.top().r])) q.pop(); 
        if(q.empty()) break; //堆为空直接g；
        node now = q.top(); //now 为堆顶的三个元素(a[i]元素下标)
        q.pop(); //删掉并更新堆顶
        int x = l[now.l],y = r[now.r]; // x为堆顶左端点的左边一个点,y同理
        l[y] = x,r[x] = y; //让x,y互相相邻
        if(bg[x] ^ bg[y]) q.push({x,y,abs(a[x] - a[y])}); //x,y互为异性丢到堆里面去
        ans.push_back(now); //把堆顶的元素丢到 ans里面去
        is[now.l] = 1,is[now.r] = 1; //标记堆顶两个端点出现过了
        
    }
    cout << ans.size() << endl; //有多少对刚才插入的堆顶元素
    for (auto i : ans ) cout << i.l << ' ' << i.r << endl; //输出每一组的左右端点
    return 0;
}