第十届蓝桥杯大赛软件类省赛C/C++研究生组 试题I：灵能传输

在游戏《星际争霸 II》中，高阶圣堂武士作为星灵的重要 AOE 单位，在游戏的中后期发挥着重要的作用，其技能”灵能风暴“可以消耗大量的灵能对一片区域内的敌军造成毁灭性的伤害。

经常用于对抗人类的生化部队和虫族的刺蛇飞龙等低血量单位。

你控制着 n 名高阶圣堂武士，方便起见标为 1,2,⋅⋅⋅,n。

每名高阶圣堂武士需要一定的灵能来战斗，每个人有一个灵能值 ai 表示其拥有的灵能的多少（ai 非负表示这名高阶圣堂武士比在最佳状态下多余了 ai 点灵能，ai 为负则表示这名高阶圣堂武士还需要 −ai 点灵能才能到达最佳战斗状态）。

现在系统赋予了你的高阶圣堂武士一个能力，传递灵能，每次你可以选择一个 i∈[2,n−1]，若 ai≥0 则其两旁的高阶圣堂武士，也就是 i−1、i+1 这两名高阶圣堂武士会从 i 这名高阶圣堂武士这里各抽取 ai 点灵能；若 ai<0 则其两旁的高阶圣堂武士，也就是 i−1,i+1 这两名高阶圣堂武士会给 i 这名高阶圣堂武士 −ai 点灵能。

形式化来讲就是 ai−1+=ai,ai+1+=ai,ai−=2ai。

灵能是非常高效的作战工具，同时也非常危险且不稳定，一位高阶圣堂武士拥有的灵能过多或者过少都不好，定义一组高阶圣堂武士的不稳定度为 maxni=1|ai|，请你通过不限次数的传递灵能操作使得你控制的这一组高阶圣堂武士的不稳定度最小。

输入格式
本题包含多组询问。输入的第一行包含一个正整数 T 表示询问组数。

接下来依次输入每一组询问。

每组询问的第一行包含一个正整数 n，表示高阶圣堂武士的数量。

接下来一行包含 n 个数 a1,a2,⋅⋅⋅,an。

输出格式
输出 T 行。

每行一个整数依次表示每组询问的答案。

数据范围
1≤T≤3,3≤n≤300000,|ai|≤109,

样例

输入样例1：
3
3
5 -2 3
4
0 0 0 0
3
1 2 3
输出样例1：
3
0
3
输入样例2：
3
4
-1 -2 -3 7
4
2 3 4 -8
5
-1 -1 6 -1 -1
输出样例2：
5
7
4

思路：贪心

选取a[i]传输灵能

1）假设a[i]>=0，则a[i-1]=a[i-1]+a[i]，a[i]= -a[i]，a[i+1]=a[i+1]+a[i]。考虑前缀和，思考便知：现s[i-1]=原s[i]，现s[i]=原s[i-1]，现s[i+1]=原s[i+1]，故选取a[i]传输灵能的效果等同于把前缀和s[i-1]和s[i]交换。

2）假设a[i]<0，则a[i-1]=a[i-1]+a[i]，a[i]=-a[i]，a[i+1]=a[i+1]+a[i]。同样考虑前缀和，可得出和1)一样的结论。

综上：也就是说通过灵能的传输，可以得到任意的前缀和序列。而a[i]=s[i]-s[i-1]，要想max(|a[i]|)也即max(|s[i]-s[i-1]|)最小，给s[i]数组排个序就好了。这一点很容易想到，你可以这样想：

假设有序序列： s1  s2  s3   s4  s5  s6  s7  s8  s9

s5乱序，序列变成：s1  s2  s5  s3  s4  s6  s7  s8  s9

观察改变后的差：s2-s1　　s3-s2　　s4-s3　　s5-s4　　s6-s5　　s7-s6　　s8-s7　　s9-s8

　　　　　　　　s2-s1　　s5-s2　　s3-s5　　s4-s3　　s6-s4　　s7-s6　　s8-s7　　s9-s8

不同的部分如绿色阴影部分，可以发现s5乱序后，绿色阴影的绝对值都增大了，这样整个序列的不稳定度可能会增加，有序序列更优。同理s5放在s7和s8之间情况同理。

实际情况下，s序列是由好几个乱序组成的，而不仅仅是一个s5。但无论怎样乱序，从上面例子可以看出，只要乱序存在就一定比有序的稳定性差。

如果s[i]都是可移动的，我们可以通过交换操作（类似冒泡排序）使得s数组有序。但是，这题并非如此，依据题目要求sn的位置是固定的，还有吗？还有s0。引入s0是为了求a1，因为a1=s1-s0=s1-0，所以s0=0.

假如排序后序列为：s1  s2  s3  s4  s5  s0  s6  s7 sn  s8 s9  s10  s11，由于s0始终在第一个位置，sn始终在最后一个位置，我们可以把序列分为3个部分s1  s2  s3  s4  s5  s0  s6  s7  s8  sn  s9  s10  s11，中间部分有序不用处理，现在只需处理绿色和蓝色部分，这两部分处理相同，所以只讲如何处理绿色部分。

s0  _   _   _   _   _   s6，我们的任务就是把s1-s5填充到横线5个位置。如果只有两个数s5，s4，一定是

s0  s4  _   _   _  s5  s6   接着

s0   s4  s2  _  s3  s5  s6   最后

s0  s4  s2  s1  s3  s5  s6

这样排列，序列的稳定性最好。

代码：

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<string>
#include<cmath>
#include<iostream>
#include<stack>;
using namespace std;
const int maxn=300000+10;
const int inf=0x3f3f3f3f;
typedef long long ll;
ll s[maxn],s_ord[maxn];
int vis[maxn];
int main()
{
    int t,n,x;
    scanf("%d",&t);
    while(t--)
    {
        memset(vis,0,sizeof(vis));
        scanf("%d",&n);
        s[0]=0;
        //int ans_test=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&x);
            //ans_test=max(ans_test,x);
            s[i]=s[i-1]+x;
        }
        ll sr=0,ed=s[n];
        int pos1,pos2;
        if(sr>ed)swap(sr,ed);
        sort(s,s+n+1);
        for(int i=0;i<=n;i++)
        {
            if(s[i]==sr)
            {
                pos1=i;
                break;
            }
        }
        for(int i=0;i<=n;i++)
        {
            if(s[i]==ed)
            {
                pos2=i;
                break;
            }
        }
        int l=0,r=n;
        for(int i=pos1;i>=0;i-=2)
        {
            s_ord[l++]=s[i];
            vis[i]=true;
        }
        for(int i=pos2;i<=n;i+=2)
        {
            s_ord[r--]=s[i];
            vis[i]=true;
        }
        for(int i=0;i<=n;i++)
        {
            if(!vis[i])
                s_ord[l++]=s[i];
        }
        ll ans=0;
        for(int i=1;i<=n;i++)
            if(abs(s_ord[i]-s_ord[i-1])>ans)
            ans=abs(s_ord[i]-s_ord[i-1]);
        printf("%lld\n",ans);
    }
    return 0;
}