B. Difference Array--Codeforces Round #808 (Div. 1)

Problem - B - Codeforces

B. Difference Array

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

You are given an array aa consisting of nn non-negative integers. It is guaranteed that aa is sorted from small to large.

For each operation, we generate a new array bi=ai+1−aibi=ai+1−ai for 1≤i

After performing n−1n−1 operations, nn becomes 11. You need to output the only integer in array aa (that is to say, you need to output a1a1).

Input

The input consists of multiple test cases. The first line contains a single integer tt (1≤t≤1041≤t≤104) — the number of test cases. The description of the test cases follows.

The first line of each test case contains one integer nn (2≤n≤1052≤n≤105) — the length of the array aa.

The second line contains nn integers a1,a2,…,ana1,a2,…,an (0≤a1≤…≤an≤5⋅1050≤a1≤…≤an≤5⋅105) — the array aa.

It is guaranteed that the sum of nn over all test cases does not exceed 2.5⋅1052.5⋅105, and the sum of anan over all test cases does not exceed 5⋅1055⋅105.

Output

For each test case, output the answer on a new line.

Example

input

Copy

5
3
1 10 100
4
4 8 9 13
5
0 0 0 8 13
6
2 4 8 16 32 64
7
0 0 0 0 0 0 0

output

Copy

81
3
1
2
0

Note

To simplify the notes, let sort(a)sort⁡(a) denote the array you get by sorting aa from small to large.

In the first test case, a=[1,10,100]a=[1,10,100] at first. After the first operation, a=sort([10−1,100−10])=[9,90]a=sort⁡([10−1,100−10])=[9,90]. After the second operation, a=sort([90−9])=[81]a=sort⁡([90−9])=[81].

In the second test case, a=[4,8,9,13]a=[4,8,9,13] at first. After the first operation, a=sort([8−4,9−8,13−9])=[1,4,4]a=sort⁡([8−4,9−8,13−9])=[1,4,4]. After the second operation, a=sort([4−1,4−4])=[0,3]a=sort⁡([4−1,4−4])=[0,3]. After the last operation, a=sort([3−0])=[3]a=sort⁡([3−0])=[3].

一道细节题，细节很多

重点是0的讨论

0 0 0 8 13为例

初始

三个零 + 8  13

差分  两个零  8  5

排序 两个零， 5 8

差分 一个零 5 3

排序 一个零 3 5

差分 没有0 3 2

排序  没有0 2 3

差分 1

我们宏观统计序列0的个数，一旦有0，就以为我们差分时第一个非零数字是要被加进去的。规律是差分一次零就会减少1，且差分过程中会出现零。

一个致命的细节是，等差数列，在差分中全变成0，需要特判。

#include
using namespace std;
const int N=1e5+100;
int T,n;
int a[N],b[N];
int main()
{
 
 
    int t;
 
    cin>>t;
 
    while(t--)
    {
        int n;
 
        cin>>n;
 
        int cnt=0,len=0;
 
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
 
        for(int i=1; i<=n; i++)
        {
            int x;
            cin>>x;
            if(!x)
                cnt++;
            else
            {
                len++;
                a[len]=x;
            }
        }
        while(len>1)
        {
 
            int newl=0;
            if(cnt)
            {
                newl++;
                cnt--;
                b[newl]=a[1];
 
            }
            for(int i=2; i<=len; i++)
            {
 
                if(a[i]-a[i-1])
                {
                    newl++;
                    b[newl]=a[i]-a[i-1];
                }
                else
                {
                    cnt++;
                }
            }
 
 
 
            sort(b+1,b+1+newl);
 
            for(int i=1; i<=newl; i++)
            {
                a[i]=b[i];
            }
 
            len=newl;
 
 
        }
 
 
        if(len==1)
            cout<1]<
        else
        {
            cout<<0<//特判全部清空
        }
 
    }
 
    return 0;
}