Educational Codeforces Round 69 (Rated for Div. 2)

                                                                                              A. DIY Wooden Ladder

                                                                                         time limit per test:2 seconds

                                                                                   memory limit per test:256 megabytes

                                                                                                             input:standard input

                                                                                                           output:standard output

Let's denote a kk-step ladder as the following structure: exactly k+2k+2 wooden planks, of which

• two planks of length at least k+1k+1 — the base of the ladder;
• kk planks of length at least 11 — the steps of the ladder;

Note that neither the base planks, nor the steps planks are required to be equal.

For example, ladders 11 and 33 are correct 22-step ladders and ladder 22 is a correct 11-step ladder. On the first picture the lengths of planks are [3,3][3,3] for the base and [1][1] for the step. On the second picture lengths are [3,3][3,3] for the base and [2][2] for the step. On the third picture lengths are [3,4][3,4] for the base and [2,3][2,3] for the steps.

You have nn planks. The length of the ii-th planks is aiai. You don't have a saw, so you can't cut the planks you have. Though you have a hammer and nails, so you can assemble the improvised "ladder" from the planks.

The question is: what is the maximum number kk such that you can choose some subset of the given planks and assemble a kk-step ladder using them?

Input

The first line contains a single integer TT (1≤T≤1001≤T≤100) — the number of queries. The queries are independent.

Each query consists of two lines. The first line contains a single integer nn (2≤n≤1052≤n≤105) — the number of planks you have.

The second line contains nn integers a1,a2,…,ana1,a2,…,an (1≤ai≤1051≤ai≤105) — the lengths of the corresponding planks.

It's guaranteed that the total number of planks from all queries doesn't exceed 105105.

Output

Print TT integers — one per query. The ii-th integer is the maximum number kk, such that you can choose some subset of the planks given in the ii-th query and assemble a kk-step ladder using them.

Print 00 if you can't make even 11-step ladder from the given set of planks.

Example

input

Copy

4
4
1 3 1 3
3
3 3 2
5
2 3 3 4 2
3
1 1 2

output

Copy

2
1
2
0

Note

Examples for the queries 1−31−3 are shown at the image in the legend section.

The Russian meme to express the quality of the ladders:

                                                                                          

题解: n 个木棍，搭建 k 步梯的条件:

      1.有 k + 2个木头

      2.k + 2 个木头中选取最大的两个基地

      3.剩下的有多少个木头小于基地中最小的木头。

核心方程：min(a[n-1]-1,min(a[n-2]-1,n-2))

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
int main()
{
    int T,a[100010];
    while(~scanf(" %d",&T))
    {
        memset(a,0,sizeof(a));
        while(T--)
        {
            int n;
            scanf(" %d",&n);
            for(int i = 0; i < n; i++)
                scanf("%d",&a[i]);
            sort(a,a+n);
           cout<<min(a[n-1]-1,min(a[n-2]-1,n-2))<<endl;
        }
    }
    return 0;
}

                                                                                                                  B. Pillars

                                                                                                      time limit per test:1.5 seconds

                                                                                                memory limit per test:256 megabytes

                                                                                                                          input:standard input

                                                                                                                        output:

standard output

There are nn pillars aligned in a row and numbered from 11 to nn.

Initially each pillar contains exactly one disk. The ii-th pillar contains a disk having radius aiai.

You can move these disks from one pillar to another. You can take a disk from pillar ii and place it on top of pillar jj if all these conditions are met:

1. there is no other pillar between pillars ii and jj. Formally, it means that |i−j|=1|i−j|=1;
2. pillar ii contains exactly one disk;
3. either pillar jj contains no disks, or the topmost disk on pillar jj has radius strictly greater than the radius of the disk you move.

When you place a disk on a pillar that already has some disks on it, you put the new disk on top of previously placed disks, so the new disk will be used to check the third condition if you try to place another disk on the same pillar.

You may take any disk and place it on other pillar any number of times, provided that every time you do it, all three aforementioned conditions are met. Now you wonder, is it possible to place all nn disks on the same pillar simultaneously?

Input

The first line contains one integer nn (3≤n≤2⋅1053≤n≤2⋅105) — the number of pillars.

The second line contains nn integers a1a1, a2a2, ..., aiai (1≤ai≤n1≤ai≤n), where aiai is the radius of the disk initially placed on the ii-th pillar. All numbers aiai are distinct.

Output

Print YES if it is possible to place all the disks on the same pillar simultaneously, and NO otherwise. You may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).

Examples

input

Copy

4
1 3 4 2

output

Copy

YES

input

Copy

3
3 1 2

output

Copy

NO

Note

In the first case it is possible to place all disks on pillar 33 using the following sequence of actions:

1. take the disk with radius 33 from pillar 22 and place it on top of pillar 33;
2. take the disk with radius 11 from pillar 11 and place it on top of pillar 22;
3. take the disk with radius 22 from pillar 44 and place it on top of pillar 33;
4. take the disk with radius 11 from pillar 22 and place it on top of pillar 33；

题解:n 个盘子从 i 移动到 j,题目限制条件：

       1. i 与 j 要相邻；

       2.呈现逐渐递减的趋势

若能够满足上述两个条件，输出"YES",反之输出"NO".

#include <cstring>
#include <cmath>
#include <cstdio>
#include <cctype>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <iostream>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <complex>
#include <stack>
#include <bitset>
#include <iomanip>
#include <list>
#if __cplusplus >= 201103L
#include <unordered_map>
#include <unordered_set>
#endif // __cplusplus
#define ll long long
#define ull unsigned long long
using namespace std;
const double clf = 1e-8;
const int INF = 0x7fffffff;
const int MMAX = 0xfffffff;
const int mod = 1e9 + 7;
int arr[200010];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n,position,MAXX = -1;
    cin>>n;
    for(int i = 1; i <= n; i++)
    {
        cin>>arr[i];
        if(arr[i] > MAXX)
        {
            MAXX = arr[i];
            position = i;
        }
    }
    for(int i = position; i <= n; i++)
        if(arr[i] < arr[i+1])
        {
            printf("NO\n");
            return 0;
        }
    for(int i = position; i > 0; i--)
        if(arr[i] < arr[i-1])
        {
            printf("NO\n");
            return 0;
        }
    printf("YES\n");
    return 0;
}

                                                                                                             C. Array Splitting

                                                                                                       time limit per test:2 seconds

                                                                                                 memory limit per test:256 megabytes

                                                                                                                           input:standard input

                                                                                                                         output:standard output

You are given a sorted array a1,a2,…,ana1,a2,…,an (for each index i>1i>1 condition ai≥ai−1ai≥ai−1 holds) and an integer kk.

You are asked to divide this array into kk non-empty consecutive subarrays. Every element in the array should be included in exactly one subarray.

Let max(i)max(i) be equal to the maximum in the ii-th subarray, and min(i)min(i) be equal to the minimum in the ii-th subarray. The cost of division is equal to ∑i=1k(max(i)−min(i))∑i=1k(max(i)−min(i)). For example, if a=[2,4,5,5,8,11,19]a=[2,4,5,5,8,11,19] and we divide it into 33 subarrays in the following way: [2,4],[5,5],[8,11,19][2,4],[5,5],[8,11,19], then the cost of division is equal to (4−2)+(5−5)+(19−8)=13(4−2)+(5−5)+(19−8)=13.

Calculate the minimum cost you can obtain by dividing the array aa into kk non-empty consecutive subarrays.

Input

The first line contains two integers nn and kk (1≤k≤n≤3⋅1051≤k≤n≤3⋅105).

The second line contains nn integers a1,a2,…,ana1,a2,…,an (1≤ai≤1091≤ai≤109, ai≥ai−1ai≥ai−1).

Output

Print the minimum cost you can obtain by dividing the array aa into kk nonempty consecutive subarrays.

Examples

input

Copy

6 3
4 8 15 16 23 42

output

Copy

12

input

Copy

4 4
1 3 3 7

output

Copy

0

input

Copy

8 1
1 1 2 3 5 8 13 21

output

Copy

20

Note

In the first test we can divide array aa in the following way: [4,8,15,16],[23],[42][4,8,15,16],[23],[42].

  题解：n 个数分解成  k 个区间，用区间最大值减去最小值，问：m 个数 k 个 区间的最小值。

差分乱搞

#include <iostream>
#include <cstdio>
#include <algorithm>
#define ll long long
using namespace std;
const int N = 3e5 + 7;
int a[N],dis[N];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    int n,k;
    cin>>n>>k;
    for(int i = 0; i < n; i++)
        cin>>a[i];
    for(int i = 0; i < n - 1; i++)
        dis[i] = a[i+1] - a[i];
    sort(dis,dis+n-1);
    ll ans = 0;
    for(int i = 0; i < n - k; i++)
        ans += dis[i];
    cout<<ans<<endl;
    return 0;
}

                                                                                                                   D. Yet Another Subarray Problem

                                                                                                                  time limit per test:2 seconds

                                                                                                            memory limit per test:256 megabytes

                                                                                                                                      input:standard input

                                                                                                                                    output:standard output

You are given an array a1,a2,…,ana1,a2,…,an and two integers mm and kk.

You can choose some subarray al,al+1,…,ar−1,aral,al+1,…,ar−1,ar.

The cost of subarray al,al+1,…,ar−1,aral,al+1,…,ar−1,ar is equal to ∑i=lrai−k⌈r−l+1m⌉∑i=lrai−k⌈r−l+1m⌉, where ⌈x⌉⌈x⌉ is the least integer greater than or equal to xx.

The cost of empty subarray is equal to zero.

For example, if m=3m=3, k=10k=10 and a=[2,−4,15,−3,4,8,3]a=[2,−4,15,−3,4,8,3], then the cost of some subarrays are:

• a3…a3:15−k⌈13⌉=15−10=5a3…a3:15−k⌈13⌉=15−10=5;
• a3…a4:(15−3)−k⌈23⌉=12−10=2a3…a4:(15−3)−k⌈23⌉=12−10=2;
• a3…a5:(15−3+4)−k⌈33⌉=16−10=6a3…a5:(15−3+4)−k⌈33⌉=16−10=6;
• a3…a6:(15−3+4+8)−k⌈43⌉=24−20=4a3…a6:(15−3+4+8)−k⌈43⌉=24−20=4;
• a3…a7:(15−3+4+8+3)−k⌈53⌉=27−20=7a3…a7:(15−3+4+8+3)−k⌈53⌉=27−20=7.

Your task is to find the maximum cost of some subarray (possibly empty) of array aa.

Input

The first line contains three integers nn, mm, and kk (1≤n≤3⋅105,1≤m≤10,1≤k≤1091≤n≤3⋅105,1≤m≤10,1≤k≤109).

The second line contains nn integers a1,a2,…,ana1,a2,…,an (−109≤ai≤109−109≤ai≤109).

Output

Print the maximum cost of some subarray of array aa.

Examples

input

Copy

7 3 10
2 -4 15 -3 4 8 3

output

Copy

7

input

Copy

5 2 1000
-13 -4 -9 -20 -11

output

Copy

0

 题解：

        1.确定状态：dp[ i ][ j ] 表示第 i 个数，长度为 j 的区间

        2.状态转移方程：dp[ i ][ j ] = dp[ i - 1][ j - 1] + a[ i ]( j > 1)

                                    dp[ i ][ j ] = max(dp[ i - 1][ m - 1 ] + a[ i ] - k,a[ i ] - k)(j == 1)

                                    dp[ i ][ j ] = dp[ i - 1][ m - 1 ] + a[ i ];

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 3e5 + 7;
const int inf = 0x3f3f3f3f;
ll dp[N][11];  /*dp[i][j]代表的是以i为末尾位，长度对m取余等于j的这一段长度的计算和
*/
ll a[N];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int n,m,k;
    cin>>n>>m>>k;
    for(int i = 1; i <= n; ++i)
        cin>>a[i];
    ll ans = 0;
    memset(dp,-inf,sizeof(dp));
    if(m == 1)
    {
        for(int i = 1; i <= n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                dp[i][j] = max(dp[i - 1][0] + a[i] - k,a[i] - k);
                ans = max(dp[i][j],ans);
            }
        }
    }
    else
    {
        for(int i = 1; i <= n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                if(j == 0)
                    dp[i][j] = dp[i - 1][m - 1] + a[i];
                else if(j == 1) /*j == 1代表现在末尾取到第i位的长度比之前取到i-1位多了一个余数1，由于向上去整，所以多剪掉了一个k，还得在加上一个a[i]*/
                    dp[i][j] = max(dp[i - 1][0] + a[i] - k,a[i] - k);
                else
                    dp[i][j] = dp[i - 1][j - 1] + a[i];
                ans = max(dp[i][j],ans);
            }
        }
    }
    cout<<ans<<endl;
    return 0;
}