BZOJ1150 || 洛谷P3620 [APIO/CTSC 2007]数据备份【二叉堆+链表】

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 = 2 km。这种配对方案需要总长 4km 的网络电缆，满足距离之和最小的要求。

Input

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

Output

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

---

题目分析

不难想到
为了使布线长度尽量小，每对布线的办公楼一定是相邻的
所以我们可以在读入时计算差分数组保存每相邻两个办公楼的距离
这样问题转化为
在差分数组中找k个数，满足k个数之和最小且互不相邻

设差分数组为b[]
其中最小的数为b[i]
显然最优解必定是一下其中一种
1.包含b[i]以及除b[i-1]和b[i+1]的数
2.包含b[i-1]和b[i+1]以及除b[i]，b[i-2]，b[i+2]

从这一点扩展
可以先取b[i]，并以b[i-1]+b[i+1]-b[i]替换
然后在新数列中继续重复k-1次得到最后结果
这样若b[i]不属于最优解，则b[i-1]+b[i+1]-b[i]必定被选，满足了上述第二种情况

具体做法是
将原差分数组每个值插入堆
并将数组以链表串起来
每次取堆顶最小值更新答案，删除
设最小值编号为i
那么在插入b[ pre[i] ]+b[ nxt[i] ]-b[i]
并更新链表
重复k次即得最优解

---

#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
typedef long long lt;

lt read()
{
    lt f=1,x=0;
    char ss=getchar();
    while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
    while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
    return f*x;
}

const int maxn=500010;
int n,k,cnt;
lt a[maxn],b[maxn];
struct node{lt val;int num;}mi[maxn];
int pre[maxn],nxt[maxn],judge[maxn];
lt ans;

void swapp(int x,int y)
{
    node tt=mi[x];
    mi[x]=mi[y]; mi[y]=tt;
}

void ins(lt val,int num)
{
    mi[++cnt].val=val; mi[cnt].num=num;
    int p=cnt;
    while(p>1)
    {
        if(mi[p>>1].val>mi[p].val){ swapp(p,p>>1); p>>=1;}
        else break;
    }
}

void pop()
{
    mi[1]=mi[cnt--];
    int p=1,s=p<<1;
    while(s<=cnt)
    {
        if(s<cnt&&mi[s].val>mi[s+1].val) s++;
        if(mi[p].val>mi[s].val){ swapp(p,s); p=s; s=p<<1;}
        else break; 
    }
}

int main()
{
    n=read();k=read();
    for(int i=1;i<=n;++i) a[i]=read();
    for(int i=1;i<n;++i)
    {
        b[i]=a[i+1]-a[i];
        ins(b[i],i);
        pre[i]=i-1; nxt[i]=i+1;
    }
    b[0]=b[n]=2e9;//注意0号和n号赋极大值
    nxt[0]=1; pre[n+1]=n;
    while(k--)
    {
        while(judge[mi[1].num]) pop();
        int val=mi[1].val,num=mi[1].num; pop();//取堆顶最小值

        ans+=val;
        b[num]=b[pre[num]]+b[nxt[num]]-b[num];//新插入得值
        judge[pre[num]]=judge[nxt[num]]=1;//两旁得值不能再取

        pre[num]=pre[pre[num]]; nxt[pre[num]]=num;//更新链表
        nxt[num]=nxt[nxt[num]]; pre[nxt[num]]=num;

        ins(b[num],num);//插入新值
    }
    printf("%lld",ans);
    return 0;
}