Problem

Tambourine has prepared a fitness program so that she can become more fit! The program is made ofNsessions. During the i-th session, Tambourine will exercise forM_iminutes. The number of minutes she exercises in each session arestrictly increasing.

Thedifficultyof her fitness program is equal to the maximum difference in the number of minutes between any two consecutive training sessions.

To make her program less difficult, Tambourine has decided to add up toKadditional training sessions to her fitness program. She can add these sessions anywhere in her fitness program, and exercise any positive integer number of minutes in each of them. After the additional training session are added, the number of minutes she exercises in each session must still be strictly increasing. What is the minimum difficulty possible?

Input

The first line of the input gives the number of test cases,T.Ttest cases follow. Each test case begins with a line containing the two integersNandK. The second line containsNintegers, the i-th of these isM_i, the number of minutes she will exercise in the i-th session.

Output

For each test case, output one line containingCase #x: y

Limits

Time limit: 20 seconds per test set.
Memory limit: 1GB.
1 ≤T≤ 100.
For at most 10 test cases, 2 ≤N≤ 10⁵.
For all other test cases, 2 ≤N≤ 300.
1 ≤M_i≤ 10⁹.
M_i<M_i+1for all i.

Test set 1

K= 1.

Test set 2

1 ≤K≤ 10⁵.

Samples

1
3 1
100 200 230
  

Case #1: 50
  

3
5 2
10 13 15 16 17
5 6
9 10 20 26 30
8 3
1 2 3 4 5 6 7 10
  

Case #1: 2
Case #2: 3
Case #3: 1
  

Sample #1

In Case #1: Tambourine can add up to one session. The added sessions are marked in bold: 100150200 230. The difficulty is now 50.

Sample #2

In Case #1: Tambourine can add up to two sessions. The added sessions are marked in bold: 101113 15 16 1718. The difficulty is now 2.

In Case #2: Tambourine can add up to six sessions. The added sessions are marked in bold: 9 1012 14 16 182023262930. The difficulty is now 3.

In Case #3: Tambourine can add up to three sessions. The added sessions are marked in bold: 1 2 3 4 5 6 78 910. The difficulty is now 1. Note that Tambourine only added two sessions.

• Note #1:Only Sample #1 is a valid input for Test set 1. Consequently, Sample #1 will be used as a sample test set for your submissions.
• Note #2:Unlike previous editions, in Kick Start 2020, all test sets are visible verdict test sets, meaning you receive instant feedback upon submission.

題意：陣列有N個遞增的數字，希望加K個數字進去使得數字間的差值最大的最小。

解法：輸入的時候遍歷一遍陣列，求出當前差值最大多少，然後二分這個差值，判斷的時候就模擬一下需要插幾個數字進去，數字夠用肯定可以成功。

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstring>
 4 #include<cmath>
 5 #include<vector>
 6 #include<algorithm>
 7 #include<map>
 8 #include<stack>
 9 #include<queue>
10 using namespace std;
11 #define PI 3.14159
12 #define mm(a,b) memset(a,b,sizeof(a))
13 const int maxn = 1e5 + 10;
14 const int inf = 0x3f3f3f3f;
15 int gcd(int a,int b) {
16     return b>0 ? gcd(b,a%b):a;
17 }
18 int arr[maxn];
19 int n,k;
20 bool check(int d)
21 {
22     int valid=k;
23     for(int i=1;i<n;i++)
24     {
25         if(arr[i]-arr[i-1]>d)
26         {
27             if((arr[i]-arr[i-1])%d==0)
28             {
29                 valid=valid-(arr[i]-arr[i-1])/d+1;
30             }
31             else valid=valid-(arr[i]-arr[i-1])/d;
32             
33             if(valid<0)
34             {
35                 return false;
36             }
37         }
38     }
39     if(valid>=0) return true;
40     return false;
41 }
42 int Solve(int l,int r)
43 {
44     int ans=-1;
45     while(l<=r)
46     {
47         int mid=(l+r)/2;
48         if(check(mid))
49         {
50             ans=mid;
51             r=mid-1;
52         }
53         else
54         {
55             l=mid+1;
56         }
57     }
58     return ans;
59 }
60 
61 int main()
62 {
63     int T;
64     scanf("%d",&T);
65     int ccase=1;
66     while(T--)
67     {
68         scanf("%d %d",&n,&k);
69         int diff=0;
70         scanf("%d",&arr[0]);
71         for(int i=1;i<n;i++)
72         {
73             scanf("%d",&arr[i]);
74             diff=max(diff,arr[i]-arr[i-1]);
75         }
76         int ans=Solve(1,diff);
77         printf("Case #%d: %d\n",ccase,ans);
78         ccase++;
79     }
80     return 0;
81 }