Problem:
Score : 400 points

Problem Statement

You are given N items.

The value of the i-th item (1 \leq i \leq N) is v_i.

Your have to select at least A and at most B of these items.

Under this condition, find the maximum possible arithmetic mean of the values of selected items.

Additionally, find the number of ways to select items so that the mean of the values of selected items is maximized.

Constraints

1 \leq N \leq 50

1 \leq A,B \leq N

1 \leq v_i \leq 10^{15}

Each v_i is an integer.

Input

The input is given from Standard Input in the following format:

N A B
v_1
v_2
...
v_N

Output

Print two lines.

The first line should contain the maximum possible arithmetic mean of the values of selected items. The output should be considered correct if the absolute or relative error is at most 10^{-6}.

The second line should contain the number of ways to select items so that the mean of the values of selected items is maximized.

Sample Input 1

5 2 2
1 2 3 4 5

Sample Output 1

4.500000
1

The mean of the values of selected items will be maximized when selecting the fourth and fifth items. Hence, the first line of the output should contain 4.5.

There is no other way to select items so that the mean of the values will be 4.5, and thus the second line of the output should contain 1.

Sample Input 2

4 2 3
10 20 10 10

Sample Output 2

15.000000
3

There can be multiple ways to select items so that the mean of the values will be maximized.

Sample Input 3

5 1 5
1000000000000000 999999999999999 999999999999998 999999999999997 999999999999996

Sample Output 3

1000000000000000.000000
1

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#pragma GCC optimize ("O3")

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <queue>
#include <set>
#include <algorithm>
#include <numeric>
#include <list>
using namespace std;

using QWORD  = uint64_t;
using SQWORD = int64_t;
using DWORD  = uint32_t;
using SDWORD = int32_t;
using WORD   = uint16_t;
using SWORD  = int16_t;
using BYTE   = uint8_t;
using SBYTE  = int8_t;
using DOUBLE = double;
using FLOAT  = float;

#define MIN_SDWORD (-2147483648)
#define MAX_SDWORD (2147483647)
#define MIN_SBYTE (-128)
#define MAX_SBYTE (127)

#define MIN_SQWORD (0x8000000000000000)
#define MAX_SQWORD (0x7FFFFFFFFFFFFFFF)

#define MAX_QWORD  (0xFFFFFFFFFFFFFFFF)
#define MAX_DWORD  (0xFFFFFFFF)
#define MAX_WORD   (0xFFFF)
#define MAX_BYTE   (0xFF)

#define MAX_DOUBLE      (1.0e+308)
#define DOUBLE_EPS      (1.0e-12)
#define MIN_DOUBLE_N    (-1.0e+308)

#define ArrayLength(a)  (sizeof(a) / sizeof(a[0]))

static inline DOUBLE MAX(DOUBLE a, DOUBLE b) { return a > b ? a : b; }
static inline QWORD MAX(QWORD a, QWORD b) { return a > b ? a : b; }
static inline DWORD MAX(DWORD a, DWORD b) { return a > b ? a : b; }
static inline SDWORD MAX(SDWORD a, SDWORD b) { return a > b ? a : b; }
static inline DOUBLE MIN(DOUBLE a, DOUBLE b) { return a < b ? a : b; }
static inline QWORD MIN(QWORD a, QWORD b) { return a < b ? a : b; }
static inline DWORD MIN(DWORD a, DWORD b) { return a < b ? a : b; }
static inline SDWORD MIN(SDWORD a, SDWORD b) { return a < b ? a : b; }
static inline DOUBLE ABS(DOUBLE a) { return 0 < a ? a : -a; };

#define BYTE_BITS   (8)
#define WORD_BITS   (16)
#define DWORD_BITS  (32)
#define QWORD_BITS  (64)

#define ANS_MOD (1000000007)

static const DOUBLE d_PI = 3.14159265358979323846;
//static const DOUBLE d_PI = M_PI;


static inline bool DoubleIsEqual(DOUBLE a, DOUBLE b) {
    return ABS(a-b) < DOUBLE_EPS;
}

static inline void inputStringSpSeparated(char *pcStr)
{
    char *pcCur = pcStr;
    for (;;) {
        char c = getchar();
        if (('\n' == c) || (EOF == c) || (' ' == c)) {
            break;
        }
        *pcCur = c;
        pcCur++;
    }
    *pcCur = '\0';
}

static inline void inputString(char *pcStr)
{
    char *pcCur = pcStr;
    for (;;) {
        char c = getchar();
        if (('\n' == c) || (EOF == c)) {
            break;
        }
        *pcCur = c;
        pcCur++;
    }
    *pcCur = '\0';
}


static inline SQWORD inputSQWORD(void)
{
    SQWORD sqNumber = 0;
    SQWORD sqMultiplier = 1;
    bool bRead = false;
    for (;;) {
        char c = getchar();
        if (!bRead) {
            if ('-' == c) {
                sqMultiplier = -1;
            }
        }
        if (('0' <= c) && (c <= '9')) {
            sqNumber *= 10LL;
            sqNumber += (SQWORD)(c - '0');
            bRead = true;
        } else {
            if (bRead) {
                return sqNumber * sqMultiplier;
            }
        }
    }
}


static inline SDWORD inputSDWORD(void)
{
    SDWORD lNumber = 0;
    SDWORD lMultiplier = 1;
    bool bRead = false;
    for (;;) {
        char c = getchar();
        if (!bRead) {
            if ('-' == c) {
                lMultiplier = -1;
            }
        }
        if (('0' <= c) && (c <= '9')) {
            lNumber *= 10;
            lNumber += (c - '0');
            bRead = true;
        } else {
            if (bRead) {
                return lNumber * lMultiplier;
            }
        }
    }
}

static inline DOUBLE inputFP(void)
{
    DOUBLE dInt = 0.0;
    DOUBLE dFrac = 0.0;
    DOUBLE dMultiplier = 1.0;
    DWORD dwFpCnt = 0;
    DOUBLE *pdCur = &dInt;
    bool bRead = false;
    for (;;) {
        char c = getchar();
        if (!bRead) {
            if ('-' == c) {
                dMultiplier = -1;
            }
        }
        if ('.' == c) {
            pdCur = &dFrac;
        } else if (('0' <= c) && (c <= '9')) {
            (*pdCur) *= 10;
            (*pdCur) += (DOUBLE)(c - '0');
            bRead = true;
            if (pdCur == &dFrac) {
                dwFpCnt++;
            }
        } else {
            if (bRead) {
                return dMultiplier * (dInt + dFrac / (pow((DOUBLE)10.0 , (DOUBLE)dwFpCnt)));
            }
        }
    }
}

/*----------------------------------------------*/
/**
 *  mod による操作ライブラリ
 */
#define ANS_MOD (1000000007)

class MODINT {
    static SQWORD MOD;
    SQWORD m_x;

public:
    MODINT(SQWORD val) {
        m_x = (val % MOD + MOD) % MOD;
    };
    MODINT() {
        m_x = 0;
    }
    static void Init(SQWORD sqMod) {
        MOD = sqMod;
    }

	MODINT& operator+= (const MODINT a)
    {
        m_x = (m_x + a.m_x) % MOD; 
        return *this;
    };
	MODINT& operator-= (const MODINT a)
    { 
        m_x = (m_x - a.m_x + MOD) % MOD; 
        return *this;
    };
	MODINT& operator*= (const MODINT a)
    {
        m_x = (m_x * a.m_x) % MOD;
        return *this;
    };
    MODINT pow(SQWORD t) const {
        if (!t) return 1;
        MODINT a = pow(t>>1);
        a *= a;
        if (t&1) a *= *this;
        return a;
    }
	MODINT operator+ (const MODINT a) const {
		MODINT res(*this);
		return (res += a);
	}
	MODINT operator- (const MODINT a) const {
		MODINT res(*this);
		return (res -= a);
	}
	MODINT operator* (const MODINT a) const {
		MODINT res(*this);
		return (res *= a);
	}
	MODINT operator/ (const MODINT a) const {
		MODINT res(*this);
		return (res /= a);
	}

    /* 逆元 */
    MODINT inv() const {
        return pow(MOD-2);
    }

    /* 除算 */
    MODINT& operator/=(const MODINT a) {
        return (*this) *= a.inv();
    } 

    /* 整数版 */
	MODINT& operator+= (const SQWORD a) {*this += MODINT(a); return *this;};
	MODINT& operator-= (const SQWORD a) {*this -= MODINT(a); return *this;};
	MODINT& operator*= (const SQWORD a) {*this *= MODINT(a); return *this;};
	MODINT& operator/= (const SQWORD a) {*this /= MODINT(a); return *this;};

    SQWORD getVal() { return m_x; };
};
SQWORD MODINT::MOD = ANS_MOD;


/*----------------------------------------------*/

#define N_MAX_GOODS (50)

int main(void)
{
    SQWORD sqN = inputSQWORD();
    SQWORD sqA = inputSQWORD();
    SQWORD sqB = inputSQWORD();

    vector<SQWORD> vecsqV;

    for (SQWORD sqIdx = 0; sqIdx < sqN; sqIdx++) {
        SQWORD sqV = inputSQWORD();
        vecsqV.emplace_back(sqV);
    }
#if 0
    sort(vecsqV.begin(), vecsqV.end());
    reverse(vecsqV.begin(), vecsqV.end());
#endif

    /**
     *  dp[i][j]    i番目までの商品を考慮し、
     *              j個を選んだ時の価値の最大値と、その時の場合の数
     * 
     *  dp[i+1][j+1] = max(dp[i+1][j+1], dp[i][j] + v_i)
     */
    static SQWORD s_aasqDp[N_MAX_GOODS + 2][N_MAX_GOODS + 2];
    static SQWORD s_aasqCnt[N_MAX_GOODS + 2][N_MAX_GOODS + 2];

    for (SQWORD sqGoodsIdx = 0; sqGoodsIdx <= sqN; sqGoodsIdx++) {
        s_aasqCnt[sqGoodsIdx][0] = 1;
    }

    for (SQWORD sqSelIdx = 1; sqSelIdx <= sqB; sqSelIdx++) {
        for (SQWORD sqGoodsIdx = sqSelIdx; sqGoodsIdx <= sqN; sqGoodsIdx++) {
            SQWORD sqBuyV     = s_aasqDp[sqGoodsIdx - 1][sqSelIdx - 1] + vecsqV[sqGoodsIdx - 1];
            SQWORD sqNoBuyV   = s_aasqDp[sqGoodsIdx - 1][sqSelIdx];
            SQWORD sqBuyCnt   = s_aasqCnt[sqGoodsIdx - 1][sqSelIdx - 1];
            SQWORD sqNoBuyCnt = s_aasqCnt[sqGoodsIdx - 1][sqSelIdx];

            if (sqNoBuyV < sqBuyV) {
                /* 買う */
                s_aasqDp[sqGoodsIdx][sqSelIdx]  = sqBuyV; 
                s_aasqCnt[sqGoodsIdx][sqSelIdx] = sqBuyCnt;
            } else if (sqNoBuyV == sqBuyV) {
                /* 買う(同じ) */
                s_aasqDp[sqGoodsIdx][sqSelIdx]  = sqBuyV; 
                s_aasqCnt[sqGoodsIdx][sqSelIdx] = (sqBuyCnt + sqNoBuyCnt);
            } else {
                s_aasqDp[sqGoodsIdx][sqSelIdx]  = sqNoBuyV; 
                s_aasqCnt[sqGoodsIdx][sqSelIdx] = sqNoBuyCnt;
            }
        }
#if 0
        for (SQWORD sqGoodsIdx = 0; sqGoodsIdx <= sqN; sqGoodsIdx++) {
            printf("%lld ", s_aasqDp[sqGoodsIdx][sqSelIdx]);
        }
        printf("\n");
#endif
#if 0
        for (SQWORD sqGoodsIdx = 0; sqGoodsIdx <= sqN; sqGoodsIdx++) {
            printf("%lld ", s_aasqCnt[sqGoodsIdx][sqSelIdx]);
        }
        printf("\n");
#endif
    }

    SQWORD sqAnsCnt = 0;
    SQWORD sqMaxSum = 0;
    SQWORD sqMaxCnt = MAX_SDWORD;
    for (SQWORD sqCnt = sqA; sqCnt <= sqB; sqCnt++) {
        SQWORD sqSum = s_aasqDp[sqN][sqCnt];
        if (sqMaxSum * sqCnt < sqSum * sqMaxCnt) {
            sqMaxSum = s_aasqDp[sqN][sqCnt];
            sqMaxCnt = sqCnt;
            sqAnsCnt = s_aasqCnt[sqN][sqCnt];
        } else if (sqMaxSum * sqCnt == sqSum * sqMaxCnt) {
            sqAnsCnt += s_aasqCnt[sqN][sqCnt];
        } else {
            ;
        }
    }
    printf("%0.10f\n", (DOUBLE)sqMaxSum / (DOUBLE)sqMaxCnt);
    printf("%lld\n", sqAnsCnt);

    return 0;
}