bzoj 1150 [CTSC2007]数据备份Backup 贪心+优先队列

题目大意：
直线上有n个点，选择2k个互不相同的点，使他们两两配对，求所有点对的最小距离和。

题目分析：
（先扯一波淡）
一开始觉得n*n *k的dp可做，恩（点头）
然后看了一眼数据范围……
这个dp可优化到n*k，恩（点头）
然后再看一眼数据范围……
换个做法，网络流也能跑，恩（点头）
然后建完图跑一下……
行了我AFO了

很显然我们选择的每一对点必须相邻，否则相邻的点对一定比不相邻的点对更优。
那么可选的点对就只有n-1个了。
我们贪心的每次选择代价最小的点对，显然这是不对的，所以就要用可修正的贪心策略。
假设我们选择了a[i]-a[i-1]这一对点，那么a[i-1]-a[i-2]和a[i+1]-a[i]显然就选不了了，
所以要把这两个点从中删去，但是有可能更优的方案使选择这两个而不选择a[i]-a[i-1]。
所以我们就把这三个小段合并成为一个小段，变成(a[i+1]-a[i])+(a[i-1]-a[i-2])-(a[i]-a[i-1])。

（有人发现这样做之后，a[i+1]-a[i]和a[i-1]-a[i-2]总是同时被选，这是正确的，因为如果你只选择a[i+1]-a[i]，而不选择a[i-1]-a[i-2]和a[i]-a[i-1]，那么你只选择a[i]-a[i-1]一定比只选择a[i+1]-a[i]更优，所以当a[i]-a[i-1]被选之后，a[i+1]-a[i]和a[i-1]-a[i-2]一定使同时被选)

当你选择了这个新的点对的时候就相当于自动删去了a[i]-a[i-1]并且选择了他旁边的两个，这就相当于网络流中退流的过程。
刚才的那个东西就用双向链表维护一下，删除和合并操作都比较简单。
每次选择最优的答案可以用优先队列维护（对于写堆的童鞋，虽然泥萌很腻害……但是STL真是懒人神器啊=。=）

代码如下：

#include <cstdio>
#include <queue>
#define N 120000
using namespace std;
const int INF=0x3f3f3f3f;
struct List{
    int pre,nes,len,num;
    bool operator < (const List &c) const { return len>c.len; }
}a[N];
bool vis[N];
int n,k,ans;
priority_queue<List> dl;
int main()
{
    scanf("%d%d",&n,&k);
    for(int i=1,x=-INF,y;i<=n;i++)
    {
        scanf("%d",&y);
        a[i].pre=i-1;
        a[i].nes=i+1;
        a[i].len=y-x;
        a[i].num=i;
        x=y;
        dl.push(a[i]);
    }
    a[n+1].pre=n;
    a[n+1].len=INF;
    dl.push(a[n+1]);
    while(k--)
    {
        while(vis[dl.top().num]) dl.pop();
        int c=dl.top().num;
        dl.pop();
        ans+=a[c].len;
        vis[a[c].pre]=true;
        vis[a[c].nes]=true;
        a[c].len=a[a[c].pre].len+a[a[c].nes].len-a[c].len;
        a[c].pre=a[a[c].pre].pre;
        a[c].nes=a[a[c].nes].nes;
        a[a[c].pre].nes=c;
        a[a[c].nes].pre=c;
        dl.push(a[c]);
    }
    printf("%d\n",ans);
    return 0;
}