1150: [CTSC2007]数据备份Backup

Time Limit: 10 Sec  Memory Limit: 162 MB
Submit: 2899  Solved: 1172
[Submit][Status][Discuss]

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

 

思路：首先证明不取全局最小值时一定是把它相邻的两个取了。然后每次取最小值后，向堆中加入v[p -> pre] + v[p -> nex] - v[p]，这样如果之后取了这个元素，则等价于取了与p相邻的两个，并把之前取的p悔掉。

实现时用个堆与链表构成对应关系即可，第一次写得推敲一会。

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <iomanip>
#include <cctype>
#include <cassert>
#include <bitset>
#include <ctime>

using namespace std;

#define pau system("pause")
#define ll long long
#define pii pair<int, int>
#define pb push_back
#define mp make_pair
#define clr(a, x) memset(a, x, sizeof(a))

const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;

/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
tree<pli, null_type, greater<pli>, rb_tree_tag, tree_order_statistics_node_update> T;
*/

int n, k, d[100015];
struct gg {
    int l, r, v, use, index;
    gg () {}
    gg (int l, int r, int v, int use, int index) : l(l), r(r), v(v), use(use), index(index) {}
    bool operator > (const gg &g) const {
        return v > g.v;
    }
} g[200015];
priority_queue<gg, vector<gg>, greater<gg> > que;
int main() {
    scanf("%d%d", &n, &k);
    d[0] = -MOD, d[n + 1] = MOD << 1;
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &d[i]);
        g[i].l = i - 1;
        g[i].r = i + 1;
        g[i].v = d[i] - d[i - 1];
        g[i].use = 0;
        g[i].index = i;
        que.push(g[i]);
    }
    g[n + 1].l = n, g[n + 1].v = d[n + 1] - d[n], g[n + 1].use = 0, g[n + 1].index = n + 1;
    int ans = 0, cnt = 0, cnt_index = n + 1;
    while (que.size() && cnt < k) {
        gg tg = que.top(); que.pop();
        int index = tg.index;
        if (g[index].use) continue;
        //printf("l = %d, r = %d, v = %d
", tg.l, tg.r, tg.v);
        int pre = g[index].l, nex = g[index].r;
        int new_pre = pre, new_nex = nex;
        g[pre].use = g[nex].use = 1;
        if (1 != new_pre) {
            new_pre = g[new_pre].l;
        }
        if (n + 1 != new_nex) {
            new_nex = g[new_nex].r;
        }
        ans += tg.v;
        ++cnt_index;
        g[cnt_index] = gg(new_pre, new_nex, g[pre].v + g[nex].v - tg.v, 0, cnt_index);
        que.push(g[cnt_index]);
        g[new_pre].r = g[new_nex].l = cnt_index;
        ++cnt;
    }
    printf("%d
", ans);
    return 0;
}