gcj Round 1A 2015 Mushroom Monster

Problem A. Mushroom Monster

This contest is open for practice. You can try every problem as many times as you like, though we won't keep track of which problems you solve. Read the Quick-Start Guide to get started.

Small input 7 points	Solve A-small
Large input 8 points	Solve A-large

Problem

Kaylin loves mushrooms. Put them on her plate and she'll eat them up! In this problem she's eating a plate of mushrooms, and Bartholomew is putting more pieces on her plate.

In this problem, we'll look at how many pieces of mushroom are on her plate at 10-second intervals. Bartholomew could put any non-negative integer number of mushroom pieces down at any time, and the only way they can leave the plate is by being eaten.

Figure out the minimum number of mushrooms that Kaylin could have eaten using two different methods of computation:

1. Assume Kaylin could eat any number of mushroom pieces at any time.
2. Assume that, starting with the first time we look at the plate, Kaylin eats mushrooms at a constant rate whenever there are mushrooms on her plate.

For example, if the input is 10 5 15 5:

With the first method, Kaylin must have eaten at least 15 mushroom pieces: first she eats 5, then 10 more are put on her plate, then she eats another 10. There's no way she could have eaten fewer pieces.

With the second method, Kaylin must have eaten at least 25 mushroom pieces. We can determine that she must eat mushrooms at a rate of at least 1 piece per second. She starts with 10 pieces on her plate. In the first 10 seconds, she eats 10 pieces, and 5 more are put on her plate. In the next 5 seconds, she eats 5 pieces, then her plate stays empty for 5 seconds, and then Bartholomew puts 15 more pieces on her plate. Then she eats 10 pieces in the last 10 seconds.

Input

The first line of the input gives the number of test cases, T. T test cases follow. Each will consist of one line containing a single integer N, followed by a line containing N space-separated integers m_i; the number of mushrooms on Kaylin's plate at the start, and at 10-second intervals.

Output

For each test case, output one line containing "Case #x: y z", where x is the test case number (starting from 1), y is the minimum number of mushrooms Kaylin could have eaten using the first method of computation, and z is the minimum number of mushrooms Kaylin could have eaten using the second method of computation.

Limits

1 ≤ T ≤ 100.

Small dataset

2 ≤ N ≤ 10.
0 ≤ m_i ≤ 100.

Large dataset

2 ≤ N ≤ 1000.
0 ≤ m_i ≤ 10000.

Sample

Input	Output
4 4 10 5 15 5 2 100 100 8 81 81 81 81 81 81 81 0 6 23 90 40 0 100 9	Case #1: 15 25 Case #2: 0 0 Case #3: 81 567 Case #4: 181 244

/***********************************************\
 |Author: YMC
 |Created Time: 2015/4/18 9:45:31
 |File Name: A.cpp
 |Description: 
\***********************************************/
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <string>
#include <cstring>
#include <algorithm>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#define L(rt) (rt<<1)
#define R(rt) (rt<<1|1)
#define mset(l,n) memset(l,n,sizeof(l))
#define rep(i,n) for(int i=0;i<n;++i)
#define maxx(a) memset(a, 0x3f, sizeof(a))
#define zero(a) memset(a, 0, sizeof(a))
#define srep(i,n) for(int i = 1;i <= n;i ++)
#define MP make_pair
const int inf=0x3f3f3f3f ;
const double eps=1e-8 ;
const double pi=acos (-1.0);
typedef long long ll;

using namespace std;
int n;
int da[1005];
int ans1,ans2;
int mtp = 0,tp;
int main() {
	freopen("A-large.in","r",stdin); 
	freopen("out.txt","w",stdout); 
    int T;
    scanf("%d",&T);
    int cas = 1;
    while(T--) {
        ans1 = 0; ans2 = 0;
        scanf("%d",&n);
        rep(i,n) scanf("%d",&da[i]);
        mtp = 0;
        for(int i=1;i<n;++i) {
            tp = da[i-1] - da[i];
            if(tp > 0) {
                mtp = max(mtp,tp);
                ans1 += tp;
            }
        }
        for(int i=0;i<n-1;++i) {
            if(da[i] > mtp) ans2 += mtp;
            else ans2 += da[i];
        }
        printf("Case #%d: %d %d\n",cas++,ans1,ans2);
    }
	return 0;
}