编译优化（未懂，一定要搞懂）

编译优化

众所周知，衡量一个编译器是否优秀的标准，除了它的编译速度和正确性以外，编译出的代码的质量也很重要。最近，作为XCC系列编译器作者的Dr. X发明了一种跨时代的优化算法：“NanGe不等式优化”。一个程序可以看成是由若干个连续的函数构成的，NanGe不等式算法能针对某一个函数进行优化，得到一个优化效果值, 不同的函数的效果值可能是不同的。但这个算法还有一个很大的Bug：
该算法不能同时优化相邻的两个函数，否则就会直接Compile Error，值得注意的是，一个程序的第一个函数和最后一个函数也算是相邻的。
现在给你一个程序从头到尾每个函数的优化效果值，Dr. X想用NanGe不等式对该程序的M个函数进行优化，他该怎么选择才能使总的优化效果值最大（前提是不能出现错误）？如果错误不能避免，请输出“Error!”

输入格式：
输入文件的第一行包含两个正整数n、m。
第二行为n个整数Ai。
输出格式：
输出文件仅一个整数，表示最后对该程序进行优化后的最大效果值。如果无解输出“Error!”，不包含引号。
样例输入：
样例输入1：
7 3
1 2 3 4 5 6 7

样例输入2：
7 4
1 2 3 4 5 6 7
样例输出：
样例输出1：
15

样例输出2：
Error!
数据范围：
对于全部数据：m<=n；-1000<=Ai<=1000
N的大小对于不同数据有所不同：
数据编号 N的大小 数据编号 N的大小
1 40 11 2013
2 45 12 5000
3 50 13 10000
4 55 14 49999
5 200 15 111111
6 200 16 148888
7 1000 17 188888
8 2010 18 199999
9 2011 19 199999
10 2012 20 200000
提示：
remove!!!

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
#define INF 10000
#define N 200001
#define PER(i,a,b) for(int i=a;i<=b;i++)
int n,t[2*N],pos[N],l[N*2],r[N*2],val[N],fa,m,ans;
void up(int x)
{
    while(val[t[x]]>val[t[x/2]]&&x>1) {swap(t[x],t[x/2]);swap(pos[t[x]],pos[t[x/2]]);x/=2;}  
}
void down(int x)
{
    int j;
    while(x*2<=n)
    {
        if(x*2==n||val[t[x*2]]>=val[t[x*2+1]]) j=x*2;else j=x*2+1;
        if(val[t[j]]>=val[t[x]])
        {
            swap(t[j],t[x]);swap(pos[t[j]],pos[t[x]]);
        }
        else break;
        x=j;
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    if(n/2<m)
    {
        cout<<"Error!\n";
        return 0;
    }
    PER(i,1,n)
    {
        scanf("%d",&val[i]);
        pos[i]=i;
        t[i]=i;
        up(i);
        l[i]=i-1;
        r[i]=i+1;
    }
    l[1]=n;r[n]=1;
    while(m--)
    {
        int x=t[1];
        ans+=val[x];
        val[x]=val[l[x]]+val[r[x]]-val[x];
        val[l[x]]=-INF;
        down(pos[l[x]]);val[r[x]]=-INF;down(pos[r[x]]);down(1);
        l[x]=l[l[x]];r[x]=r[r[x]];
        r[l[x]]=x;l[r[x]]=x;
    }
    cout<<ans<<"\n";
}

未懂，要弄懂。这个题标准解法是借鉴网络流中的残余流思想，用堆来维护解决。映射建大根堆，记录每一个数值在堆中的位置好方便删除操作。每回出堆顶元素后，a[k]=a[l[k]]+a[r[k]]-a[k],l[k]和r[k]是k的左边节点和右边节点，即双链表思想，再将a[l[k]]和a[r[k]]删除，将新的a[k]加入堆中。