BZOJ 1150 - 数据备份Backup - [小顶堆][CTSC2007]

题目链接：https://www.lydsy.com/JudgeOnline/problem.php?id=1150

Time Limit: 10 Sec　　Memory Limit: 162 M

Description

　　你在一家 IT 公司为大型写字楼或办公楼（offices）的计算机数据做备份。然而数据备份的工作是枯燥乏味的，因此你想设计一个系统让不同的办公楼彼此之间互相备份，而你则坐在家中尽享计算机游戏的乐趣。已知办公楼都位于同一条街上。你决定给这些办公楼配对（两个一组）。每一对办公楼可以通过在这两个建筑物之间铺设网络电缆使得它们可以互相备份。然而，网络电缆的费用很高。当地电信公司仅能为你提供 K 条网络电缆，这意味着你仅能为 K 对办公楼（或总计2K个办公楼）安排备份。任一个办公楼都属于唯一的配对组（换句话说，这 2K 个办公楼一定是相异的）。此外，电信公司需按网络电缆的长度（公里数）收费。因而，你需要选择这 K 对办公楼使得电缆的总长度尽可能短。换句话说，你需要选择这 K 对办公楼，使得每一对办公楼之间的距离之和（总距离）尽可能小。下面给出一个示例，假定你有 5 个客户，其办公楼都在一条街上，如下图所示。这 5 个办公楼分别位于距离大街起点 1km, 3km, 4km, 6km 和 12km 处。电信公司仅为你提供 K=2 条电缆。

　　上例中最好的配对方案是将第 1 个和第 2 个办公楼相连，第 3 个和第 4 个办公楼相连。这样可按要求使用K=2 条电缆。第 1 条电缆的长度是 3km-1km=2km ，第 2 条电缆的长度是 6km-4km=2km。这种配对方案需要总长4km 的网络电缆，满足距离之和最小的要求。

Input

第一行包含整数n和k
其中n（2≤n≤100000）表示办公楼的数目，k（1≤k≤n/2）表示可利用的网络电缆的数目。
接下来的n行每行仅包含一个整数（0≤s≤1000000000）,表示每个办公楼到大街起点处的距离。
这些整数将按照从小到大的顺序依次出现。

Output

输出应由一个正整数组成，给出将2K个相异的办公楼连成k对所需的网络电缆的最小总长度。

Sample Input
5 2

1

3

4

6

12

Sample Output
4

题解：

显然肯定是选择相邻的两栋楼架设电缆，那么可以将 $1 \sim n$ 个办公楼变成 $1 \sim n-1$ 个间距，并将其存储在一个数组 $d$ 中。

问题转化为，在 $n-1$ 个 $d_i$ 中，选择 $k$ 个任意两两间均不相邻的数字，使它们的和最小。

假设 $d[1:n-1]$ 中最小的数为 $d_k$，我们可以证明对于 $d_{k-1}$ 和 $d_{k+1}$ 这两个数，要么同时选，要么都不选，

证明不存在只选 $d_{k-1}$ 和 $d_{k+1}$ 中某一个这种情况：若我只选择了 $d_{k-1}$ 而没有选择 $d_{k+1}$，那么我必然可以将 $d_{k-1}$ 改选为 $d_k$，既不会违反两两不相邻的条件，同时又获得了一个更优解，因此不可能存在只选 $d_{k-1}$ 和 $d_{k+1}$ 中某一个这种情况。

同时我们还可以知道，如果不选 $d_{k-1}$ 和 $d_{k+1}$，那么必然会选择 $d_k$，这是显然的。

换句话说，现在就变成了一道二选一：1、选 $d_k$；2、选 $d_{k-1}$ 和 $d_{k+1}$。

因此，可以先选择 $d_k$，然后将 $d_{k-1},d_k,d_{k+1}$ 从数组 $d$ 中删去，添加一个新元素 $d_{k-1} + d_{k+1} - d_k$，然后即变成从新的数组 $d$ 中选择 $k-1$ 个任意两两间均不相邻的数字，使它们的和最小。这样一来，一旦选到 $d_{k-1} + d_{k+1} - d_k$，就相当于抛弃原来的 $d_k$ 转而选择 $d_{k-1}$ 和 $d_{k+1}$。

至于具体实现，对于数组 $d$ 可以构建一个链表结构，用 $pre$ 和 $nxt$ 记录前后相邻的元素。同时，建立一个小顶堆，堆内存储的是指向链表某个位置的指针（记为“节点值”），堆内元素比较大小可以直接由指针 $O(1)$ 得到链表中实际存储的值，即看做节点的键值（节点的键值不同于节点值），用该键值进行节点间的两两比较。

这样一来，每次删除链表内的某一节点可以 $O(1)$ 完成。而要删除堆中对应的指向该节点的指针，由于我们手写二叉堆只能完成删除 $heap$ 数组中指定位置的元素，也就是说，我们需要另开一个数组，用来存储“节点值”到“节点位置”的映射关系，这也正是我们为什么要在堆内存储指针的原因，因为指向链表指定位置的指针是唯一的，方便构建映射关系。

AC代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=+;

int n,k;
int d[maxn],pre[maxn],nxt[maxn];

struct Heap
{
    int sz;
    int heap[maxn],pos[maxn];
    void up(int now)
    {
        while(now>)
        {
            int par=now>>;
            if(d[heap[now]]<d[heap[par]])
            {
                swap(heap[par],heap[now]);
                swap(pos[heap[par]],pos[heap[now]]);
                now=par;
            }
            else break;
        }
    }
    void push(int x)
    {
        heap[++sz]=x;
        pos[x]=sz;
        up(sz);
    }
    inline int top(){return heap[];}
    void down(int now)
    {
        while((now<<)<=sz)
        {
            int nxt=now<<;
            if(nxt+<=sz && d[heap[nxt+]]<d[heap[nxt]]) nxt++;
            if(d[heap[now]]>d[heap[nxt]])
            {
                swap(heap[now],heap[nxt]);
                swap(pos[heap[now]],pos[heap[nxt]]);
                now=nxt;
            }
            else break;
        }
    }
    void pop()
    {
        heap[]=heap[sz--];
        pos[heap[]]=;
        down();
    }
    void del(int p) //删除存储在数组下标为p位置的节点
    {
        heap[p]=heap[sz--];
        pos[heap[p]]=p;
        up(p), down(p);
    }
    void delx(int x){del(pos[x]);} //删除堆中值为x的节点
    inline void clr(){sz=;}
}h;

int main()
{
    cin>>n>>k;
    for(int i=;i<=n;i++) scanf("%d",&d[i]);
    h.clr();
    for(int i=;i<n;i++)
    {
        d[i]=d[i+]-d[i];
        pre[i]=i-;
        nxt[i]=(i+)%n;
        h.push(i);
    }

    int ans=;
    while(k--)
    {
        int x=h.top(); h.pop();
        ans+=d[x];
        if(!pre[x] && !nxt[x]) break;
        if(!pre[x])
        {
            h.delx(nxt[x]);
            pre[nxt[nxt[x]]]=;
        }
        else if(!nxt[x])
        {
            h.delx(pre[x]);
            nxt[pre[pre[x]]]=;
        }
        else
        {
            h.delx(pre[x]);
            h.delx(nxt[x]);
            d[x]=d[pre[x]]+d[nxt[x]]-d[x];
            h.push(x);
            pre[x]=pre[pre[x]]; nxt[pre[x]]=x;
            nxt[x]=nxt[nxt[x]]; pre[nxt[x]]=x;
        }
    }
    cout<<ans<<endl;
}

本代码大量参考《算法竞赛进阶指南》给出的标程（我自己敲…已经敲自闭了……）。

这种在堆中存储唯一编码的方式，类似于二叉堆优化Dijkstra中二叉堆的写法，比直接在堆中存储结构体要灵活。