编译优化已弄懂，详解

编译优化

众所周知，衡量一个编译器是否优秀的标准，除了它的编译速度和正确性以外，编译出的代码的质量也很重要。最近，作为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";
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

未懂，要弄懂。这个题标准解法是借鉴网络流中的残余流思想，用堆来维护解决。映射建大根堆，记录每一个数值在堆中的位置好方便删除操作。每回出堆顶元素后，a[k]=a[l[k]]+a[r[k]]-a[k],l[k]和r[k]是k的左边节点和右边节点，即双链表思想，再将a[l[k]]和a[r[k]]删除，将新的a[k]加入堆中。就是说把三个打包后仍满足取了之后两边不能去的性质，且满足每次多一个点就可以A了