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



Sample input:
5 2 2
1 2 3 4 5


Sample output:
4.500000
1

Submission status: Wrong Answer

Solution code:
import functools
from heapq import*
from collections import deque
import collections
import math
from collections import defaultdict
import sys
# input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7
inf = float("inf")


def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    # divisors.sort()
    return divisors


def factorize(n):
    fct = []  # prime factor
    b, e = 2, 0  # base, exponent
    while b * b <= n:
        while n % b == 0:
            n = n // b
            e = e + 1
        if e > 0:
            fct.append((b, e))
        b, e = b + 1, 0
    if n > 1:
        fct.append((n, 1))
    return fct


def is_prime(n):
    if n == 1:
        return False

    for k in range(2, int(math.sqrt(n)) + 1):
        if n % k == 0:
            return False

    return True


def primes(n):
    is_prime = [True] * (n + 1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5) + 1):
        if not is_prime[i]:
            continue
        for j in range(i * 2, n + 1, i):
            is_prime[j] = False
    return [i for i in range(n + 1) if is_prime[i]]


def modpow(a, n, mod):
    res = 1
    while n > 0:
        if n & 1:
            res = res * a % mod
        a = a * a % mod
        n >>= 1
    return res


def modinv(a, mod):
    return modpow(a, mod - 2, mod)


def cnk(a, b):
    MOD = 10**9+7
    ret = 1
    for i in range(b):
        ret *= (a-i)
        ret %= MOD
        ret = ret * modinv(i+1, MOD) % MOD
    return ret


def Dijkstra(n, start, e):
    # input parm e
    # e = [[]for i in range(n)]
    # e[x].append([y, 1])
    # e[y].append([x, 1])
    n += 10

    d = [float("inf") for i in range(n)]
    d[start] = 0

    pathnum = [0 for i in range(n)]
    pathnum[start] = 1

    visited = [False for i in range(n)]
    q = []
    heappush(q, (0, start))
    while len(q):
        now_distance, v = heappop(q)
        if visited[v]:
            continue
        visited[v] = True
        for next_v, next_distance in e[v]:
            if visited[next_v]:
                continue
            dd = now_distance + next_distance
            if d[next_v] > dd:
                d[next_v] = dd
                heappush(q, (dd, next_v))
            if d[next_v] == dd:
                pathnum[next_v] += pathnum[v]
                pathnum[next_v] %= MOD

    return d, pathnum


def warshall_floyd(d):
    for k in range(n):
        for i in range(n):
            for j in range(n):
                d[i][j] = min(d[i][j], d[i][k] + d[k][j])
    return d


class UnionFind:
    def __init__(self, n):
        self.sz = [-1 for i in range(n)]

    # 検索
    def find(self, x):
        if self.sz[x] < 0:
            return x
        else:
            self.sz[x] = self.find(self.sz[x])
            return self.sz[x]

    # 併合

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return False
        if self.sz[x] > self.sz[y]:
            x, y = y, x
        self.sz[x] += self.sz[y]
        self.sz[y] = x

    # 同じ集合に属するか判定
    def same(self, x, y):
        return self.find(x) == self.find(y)

    # xが含まれている集合のサイズを求める
    def size(self, x):
        return -self.sz[self.find(x)]


class WeightedUnionFind:
    def __init__(self, n):
        self.par = [i for i in range(n+1)]
        self.rank = [0] * (n+1)
        # 根への距離を管理
        self.weight = [0] * (n+1)

    # 検索
    def find(self, x):
        if self.par[x] == x:
            return x
        else:
            y = self.find(self.par[x])
            # 親への重みを追加しながら根まで走査
            self.weight[x] += self.weight[self.par[x]]
            self.par[x] = y
            return y

    # 併合
    def union(self, x, y, w):
        rx = self.find(x)
        ry = self.find(y)
        # xの木の高さ < yの木の高さ
        if self.rank[rx] < self.rank[ry]:
            self.par[rx] = ry
            self.weight[rx] = w - self.weight[x] + self.weight[y]
        # xの木の高さ ≧ yの木の高さ
        else:
            self.par[ry] = rx
            self.weight[ry] = -w - self.weight[y] + self.weight[x]
            # 木の高さが同じだった場合の処理
            if self.rank[rx] == self.rank[ry]:
                self.rank[rx] += 1

    # 同じ集合に属するか
    def same(self, x, y):
        return self.find(x) == self.find(y)

    # xからyへのコスト
    def diff(self, x, y):
        return self.weight[x] - self.weight[y]

#
# kruskal
#


@functools.lru_cache(maxsize=None)
class UNION_FIND(object):
    def __init__(self, n):
        self.parent = [-1 for i in range(n)]

    def root(self, x):
        if self.parent[x] < 0:
            return x
        else:
            self.parent[x] = self.root(self.parent[x])
            return self.parent[x]

    def size(self, x):
        return -self.parent[self.root(x)]

    def union(self, x, y):
        x = self.root(x)
        y = self.root(y)
        if x == y:
            return False
        if self.size(x) < self.size(y):
            x, y = y, x
        self.parent[x] += self.parent[y]
        self.parent[y] = x
        return True


def compute_mst_kruskal(max_v, edges):
    edges.sort(key=lambda x: x[2], reverse=1)
    uf = UNION_FIND(max_v)
    mst = []
    for (a, b, c, d) in edges:
        if uf.root(a-1) != uf.root(b-1):
            uf.union(a-1, b-1)
            mst += [d+1]
    return mst


# max_v, max_e = map(int, input().split())
# edges = []
# for i in range(max_e):
#     a, b, c = map(int, input().split())
#     heappush(edges, (a, b, c, i))

# mst = compute_mst_kruskal(max_v, edges)
# mst.sort()
# for i in mst:
#   print(i)

#
# Dinic
#

class Dinic:
    def __init__(self, N):
        self.N = N
        self.G = [[] for i in range(N)]

    def add_edge(self, fr, to, cap):
        forward = [to, cap, None]
        forward[2] = backward = [fr, 0, forward]
        self.G[fr].append(forward)
        self.G[to].append(backward)

    def add_multi_edge(self, v1, v2, cap1, cap2):
        edge1 = [v2, cap1, None]
        edge1[2] = edge2 = [v1, cap2, edge1]
        self.G[v1].append(edge1)
        self.G[v2].append(edge2)

    def bfs(self, s, t):
        self.level = level = [None]*self.N
        deq = deque([s])
        level[s] = 0
        G = self.G
        while deq:
            v = deq.popleft()
            lv = level[v] + 1
            for w, cap, _ in G[v]:
                if cap and level[w] is None:
                    level[w] = lv
                    deq.append(w)
        return level[t] is not None

    def dfs(self, v, t, f):
        if v == t:
            return f
        level = self.level
        for e in self.it[v]:
            w, cap, rev = e
            if cap and level[v] < level[w]:
                d = self.dfs(w, t, min(f, cap))
                if d:
                    e[1] -= d
                    rev[1] += d
                    return d
        return 0

    def flow(self, s, t):
        flow = 0
        INF = 10**9 + 7
        G = self.G
        while self.bfs(s, t):
            *self.it, = map(iter, self.G)
            f = INF
            while f:
                f = self.dfs(s, t, INF)
                flow += f
        return flow

# V, E, r = map(int, input().split())
# edges = []
# for i in range(E):
#     s, t, d = map(int, input().split())
#     edges.append([s, t, d])

# d = BellmanFord(edges, V, r)
# if d == -1:
#     print("NEGATIVE CYCLE")
#     exit()

# for i in range(V):
#     if d[i] == float("inf"):
#         print("INF")
#     else:
#         print(d[i])


ok = [False for i in range(2505)]


def Bellmanford(edges, n, s):
    d = [float("inf") for i in range(n)]
    d[s] = 0

    for i in range(n):
        for x, y, z in edges:
            if not ok[x] or not ok[y]:  # 0からn-1へ到達できない点は無視
                continue
            if d[y] > d[x] + z:
                d[y] = d[x] + z
                if i == n - 1:
                    print(-1)
                    exit()
    print(max(0, -d[n - 1]))


def nck(n, k):
    ret = 1
    for i in range(min(n - k, k)):
        ret *= (n - i)
        ret /= (i + 1)
    return ret


def main():
    n, a, b = map(int, input().split())
    v = list(map(int, input().split()))

    v = sorted(v, reverse=True)
    d = defaultdict(int)
    for i in range(n):
        d[v[i]] += 1
    value = 0
    c = 0
    t = 0
    for i in range(a):
        value += v[i]
        if i == a - 1:
            t = v[i]
    print(value / a)

    for i in range(n):
        if v[i] == t:
            break
        c += d[v[i]]

    ans = 0
    if d[v[0]] == n:
        for i in range(1, b+1):
            if i >= a:
                ans += nck(d[t], i)
        print(int(ans))
    elif d[t] == 1:
        print(1)
    else:
        print(int(nck(d[t], a - c)))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import functools
from heapq import*
from collections import deque
import collections
import math
from collections import defaultdict
import sys
# input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7
inf = float("inf")


def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    # divisors.sort()
    return divisors


def factorize(n):
    fct = []  # prime factor
    b, e = 2, 0  # base, exponent
    while b * b <= n:
        while n % b == 0:
            n = n // b
            e = e + 1
        if e > 0:
            fct.append((b, e))
        b, e = b + 1, 0
    if n > 1:
        fct.append((n, 1))
    return fct


def is_prime(n):
    if n == 1:
        return False

    for k in range(2, int(math.sqrt(n)) + 1):
        if n % k == 0:
            return False

    return True


def primes(n):
    is_prime = [True] * (n + 1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5) + 1):
        if not is_prime[i]:
            continue
        for j in range(i * 2, n + 1, i):
            is_prime[j] = False
    return [i for i in range(n + 1) if is_prime[i]]


def modpow(a, n, mod):
    res = 1
    while n > 0:
        if n & 1:
            res = res * a % mod
        a = a * a % mod
        n >>= 1
    return res


def modinv(a, mod):
    return modpow(a, mod - 2, mod)


def cnk(a, b):
    MOD = 10**9+7
    ret = 1
    for i in range(b):
        ret *= (a-i)
        ret %= MOD
        ret = ret * modinv(i+1, MOD) % MOD
    return ret


def Dijkstra(n, start, e):
    # input parm e
    # e = [[]for i in range(n)]
    # e[x].append([y, 1])
    # e[y].append([x, 1])
    n += 10

    d = [float("inf") for i in range(n)]
    d[start] = 0

    pathnum = [0 for i in range(n)]
    pathnum[start] = 1

    visited = [False for i in range(n)]
    q = []
    heappush(q, (0, start))
    while len(q):
        now_distance, v = heappop(q)
        if visited[v]:
            continue
        visited[v] = True
        for next_v, next_distance in e[v]:
            if visited[next_v]:
                continue
            dd = now_distance + next_distance
            if d[next_v] > dd:
                d[next_v] = dd
                heappush(q, (dd, next_v))
            if d[next_v] == dd:
                pathnum[next_v] += pathnum[v]
                pathnum[next_v] %= MOD

    return d, pathnum


def warshall_floyd(d):
    for k in range(n):
        for i in range(n):
            for j in range(n):
                d[i][j] = min(d[i][j], d[i][k] + d[k][j])
    return d


class UnionFind:
    def __init__(self, n):
        self.sz = [-1 for i in range(n)]

    # 検索
    def find(self, x):
        if self.sz[x] < 0:
            return x
        else:
            self.sz[x] = self.find(self.sz[x])
            return self.sz[x]

    # 併合

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return False
        if self.sz[x] > self.sz[y]:
            x, y = y, x
        self.sz[x] += self.sz[y]
        self.sz[y] = x

    # 同じ集合に属するか判定
    def same(self, x, y):
        return self.find(x) == self.find(y)

    # xが含まれている集合のサイズを求める
    def size(self, x):
        return -self.sz[self.find(x)]


class WeightedUnionFind:
    def __init__(self, n):
        self.par = [i for i in range(n+1)]
        self.rank = [0] * (n+1)
        # 根への距離を管理
        self.weight = [0] * (n+1)

    # 検索
    def find(self, x):
        if self.par[x] == x:
            return x
        else:
            y = self.find(self.par[x])
            # 親への重みを追加しながら根まで走査
            self.weight[x] += self.weight[self.par[x]]
            self.par[x] = y
            return y

    # 併合
    def union(self, x, y, w):
        rx = self.find(x)
        ry = self.find(y)
        # xの木の高さ < yの木の高さ
        if self.rank[rx] < self.rank[ry]:
            self.par[rx] = ry
            self.weight[rx] = w - self.weight[x] + self.weight[y]
        # xの木の高さ ≧ yの木の高さ
        else:
            self.par[ry] = rx
            self.weight[ry] = -w - self.weight[y] + self.weight[x]
            # 木の高さが同じだった場合の処理
            if self.rank[rx] == self.rank[ry]:
                self.rank[rx] += 1

    # 同じ集合に属するか
    def same(self, x, y):
        return self.find(x) == self.find(y)

    # xからyへのコスト
    def diff(self, x, y):
        return self.weight[x] - self.weight[y]

#
# kruskal
#


@functools.lru_cache(maxsize=None)
class UNION_FIND(object):
    def __init__(self, n):
        self.parent = [-1 for i in range(n)]

    def root(self, x):
        if self.parent[x] < 0:
            return x
        else:
            self.parent[x] = self.root(self.parent[x])
            return self.parent[x]

    def size(self, x):
        return -self.parent[self.root(x)]

    def union(self, x, y):
        x = self.root(x)
        y = self.root(y)
        if x == y:
            return False
        if self.size(x) < self.size(y):
            x, y = y, x
        self.parent[x] += self.parent[y]
        self.parent[y] = x
        return True


def compute_mst_kruskal(max_v, edges):
    edges.sort(key=lambda x: x[2], reverse=1)
    uf = UNION_FIND(max_v)
    mst = []
    for (a, b, c, d) in edges:
        if uf.root(a-1) != uf.root(b-1):
            uf.union(a-1, b-1)
            mst += [d+1]
    return mst


# max_v, max_e = map(int, input().split())
# edges = []
# for i in range(max_e):
#     a, b, c = map(int, input().split())
#     heappush(edges, (a, b, c, i))

# mst = compute_mst_kruskal(max_v, edges)
# mst.sort()
# for i in mst:
#   print(i)

#
# Dinic
#

class Dinic:
    def __init__(self, N):
        self.N = N
        self.G = [[] for i in range(N)]

    def add_edge(self, fr, to, cap):
        forward = [to, cap, None]
        forward[2] = backward = [fr, 0, forward]
        self.G[fr].append(forward)
        self.G[to].append(backward)

    def add_multi_edge(self, v1, v2, cap1, cap2):
        edge1 = [v2, cap1, None]
        edge1[2] = edge2 = [v1, cap2, edge1]
        self.G[v1].append(edge1)
        self.G[v2].append(edge2)

    def bfs(self, s, t):
        self.level = level = [None]*self.N
        deq = deque([s])
        level[s] = 0
        G = self.G
        while deq:
            v = deq.popleft()
            lv = level[v] + 1
            for w, cap, _ in G[v]:
                if cap and level[w] is None:
                    level[w] = lv
                    deq.append(w)
        return level[t] is not None

    def dfs(self, v, t, f):
        if v == t:
            return f
        level = self.level
        for e in self.it[v]:
            w, cap, rev = e
            if cap and level[v] < level[w]:
                d = self.dfs(w, t, min(f, cap))
                if d:
                    e[1] -= d
                    rev[1] += d
                    return d
        return 0

    def flow(self, s, t):
        flow = 0
        INF = 10**9 + 7
        G = self.G
        while self.bfs(s, t):
            *self.it, = map(iter, self.G)
            f = INF
            while f:
                f = self.dfs(s, t, INF)
                flow += f
        return flow

# V, E, r = map(int, input().split())
# edges = []
# for i in range(E):
#     s, t, d = map(int, input().split())
#     edges.append([s, t, d])

# d = BellmanFord(edges, V, r)
# if d == -1:
#     print("NEGATIVE CYCLE")
#     exit()

# for i in range(V):
#     if d[i] == float("inf"):
#         print("INF")
#     else:
#         print(d[i])


ok = [False for i in range(2505)]


def Bellmanford(edges, n, s):
    d = [float("inf") for i in range(n)]
    d[s] = 0

    for i in range(n):
        for x, y, z in edges:
            if not ok[x] or not ok[y]:  # 0からn-1へ到達できない点は無視
                continue
            if d[y] > d[x] + z:
                d[y] = d[x] + z
                if i == n - 1:
                    print(-1)
                    exit()
    print(max(0, -d[n - 1]))


def nck(n, k):
    ret = 1
    for i in range(min(n - k, k)):
        ret *= (n - i)
        ret /= (i + 1)
    return ret


def main():
    n, a, b = map(int, input().split())
    v = list(map(int, input().split()))

    v = sorted(v, reverse=True)
    d = defaultdict(int)
    for i in range(n):
        d[v[i]] += 1
    value = 0
    c = 0
    t = 0
    for i in range(a):
        value += v[i]
        if i == a - 1:
            t = v[i]
    print(value / a)

    for i in range(n):
        if v[i] == t:
            break
        c += d[v[i]]

    ans = 0
    if d[v[0]] == n:
        for i in range(1, b+1):
            if i >= a:
                ans += nck(d[t], i)
        print(int(ans))
    else:
        print(int(nck(d[t], a - c)))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
def nck(n, k):
    ret = 1
    for i in range(min(n - k, k)):
        ret *= (n - i)
        ret /= (i + 1)
    return ret

from collections import defaultdict

def main():
    n, a, b = map(int, input().split())
    v = list(map(int, input().split()))

    v = sorted(v, reverse=True)
    d = defaultdict(int)
    for i in range(n):
        d[v[i]] += 1
    value = 0
    c = 0
    t = 0
    for i in range(b):
        if i < a:
            value += v[i]

            if i == a - 1:
                t = v[i]
    for i in range(n):
        if v[i] == t:
            break
        c += d[v[i]]
    print(value / a)
    ans = 0
    if d[v[i]] == n:
        for i in range(1, b+1):
            if i >= a:
                ans += nck(d[t], i)
        print(int(ans))
    else:
        print(int(nck(d[t], a - c)))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
def nck(n, k):
    ret = 1
    for i in range(min(n - k, k)):
        ret *= (n - i)
        ret /= (i + 1)
    return ret

from collections import defaultdict

def main():
    n, a, b = map(int, input().split())
    v = list(map(int, input().split()))

    v = sorted(v, reverse=True)
    d = defaultdict(int)
    for i in range(n):
        d[v[i]] += 1
    value = 0
    c = 0
    t = 0
    for i in range(b):
        if i < a:
            value += v[i]

            if i == a - 1:
                t = v[i]
    for i in range(n):
        if v[i] == t:
            break
        c += d[v[i]]
    print(value / a)
    ans = 0
    if d[v[i]] == n:
        for i in range(1, b+1):
            if i >= a:
                ans += nck(d[t], i)
        print(ans)
    else:
        print(nck(d[t], a - c))


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
def comb(N):
    for i in range(N+1):
        for j in range(i+1):
            if j == 0 or j == i :
                dp[i][j] = 1
            else:
                dp[i][j] = dp[i-1][j-1] + dp[i-1][j]

def main():
    global dp,N
    N, A, B = map(int, input().split())
    v = [int(i) for i in input().split()]
    v.sort(reverse=True)
    dp = [[0 for i in range(N+1)] for j in range(N+1)]
    ans = 0
    for i in range(A):
        ans += v[i]
    ans /= A
    a = 0
    b = 0
    for i in range(N):
        if v[A-1] == v[i]:
            a += 1
            if i < A :
                b += 1
    ans_2 = 0
    comb(N)
    if v[A-1] == v[0]:
        for i in range(A,B+1):
            print(dp[a][i])
            ans_2 += dp[a][i]
    else:
        ans_2 += dp[a][b]
    print(ans,ans_2)


if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
import math
n,a,b=map(int,input().split())
v=list(map(int,input().split()))
v.sort()
v.reverse()
if a==n:
  print(sum(v)/n)
  print(1)
elif v[a-1]!=v[a]:
  print(sum(v[0:a])/a)
  print(1)
elif v[0]!=v[a-1]:
  print(sum(v[0:a])/a)
  ct1=0;ct2=0
  for i in range(n):
    if v[i]==v[a-1]:
      ct1+=1
      if i<a:
        ct2+=1
  print(math.factorial(ct1)//(math.factorial(ct1-ct2)*math.factorial(ct2)))
else:
  print(sum(v[0:a])/a)
  ct1=0;ans=0
  for i in range(n):
    if v[i]==v[a-1]:
      ct1+=1
  print(2**(ct1)-1)

Submission status: Wrong Answer

Solution code:
import math
n,a,b=map(int,input().split())
v=list(map(int,input().split()))
v.sort()
v.reverse()
if a==n:
  print(sum(v)/n)
  print(1)
elif v[a-1]!=v[a]:
  print(sum(v[0:a])/a)
  print(1)
elif v[0]!=v[a-1]:
  print(sum(v[0:a])/a)
  ct1=0;ct2=0
  for i in range(n):
    if v[i]==v[a-1]:
      ct1+=1
      if i<a:
        ct2+=1
  print(ct1,ct2)
  print(math.factorial(ct1)//(math.factorial(ct1-ct2)*math.factorial(ct2)))
else:
  print(sum(v[0:a])/a)
  ct1=0;ans=0
  for i in range(n):
    if v[i]==v[a-1]:
      ct1+=1
  print(2**(ct1)-1)

Submission status: Wrong Answer

Solution code:
def main():
    N, A, B = map(int, input().split())
    v = sorted(list(map(int, input().split())), key=lambda x:-x)
    dic = {}
    kai = [1] * (N+1)
    tmp = 1
    for i in range(2, N+1):
        kai[i] = kai[i-1] * i
    # print(kai)
    for i in range(N):
        if v[i] in dic:
            dic[v[i]] += 1
        else:
            dic[v[i]] = 1
    dic = sorted(list(dic.items()), key=lambda x:-x[0])
    # print(dic)
    tmp = 0
    for i in range(len(dic)):
        if tmp + dic[i][1] < A:
            tmp += dic[i][1]
        else:
            break
    if i == 0:
        print(sum(v[:A])/A)
        ans = 0
        for j in range(A-tmp, min(B-tmp, dic[i][1])+1):
            tmp_c = int(kai[dic[i][1]] / kai[j] / kai[dic[i][1] - j])
            # print(dic[i][1], j, tmp_c)
            ans += tmp_c
        # print(dic[i][1], A - tmp, min(B - tmp, dic[i][1]))
        print(ans)
    else:
        print(sum(v[:A])/A)
        # print(dic[i][1], A - tmp)
        print(int(kai[dic[i][1]] / kai[dic[i][1] - (A - tmp)] / kai[A - tmp]))

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
def main():
    N, A, B = map(int, input().split())
    v = sorted(list(map(int, input().split())), key=lambda x:-x)
    dic = {}
    kai = [1] * (N+1)
    tmp = 1
    for i in range(2, N+1):
        kai[i] = kai[i-1] * i
    # print(kai)
    for i in range(N):
        if v[i] in dic:
            dic[v[i]] += 1
        else:
            dic[v[i]] = 1
    dic = sorted(list(dic.items()), key=lambda x:-x[0])
    # print(dic)
    tmp = 0
    for i in range(len(dic)):
        if tmp + dic[i][1] < A:
            tmp += dic[i][1]
        else:
            break
    if i == 0:
        print(sum(v[:A])/A)
        ans = 0
        for j in range(A-tmp, min(B-tmp, dic[i][1])+1):
            tmp_c = int(kai[dic[i][1]] / kai[dic[i][1] - j] / kai[j])
            # print(dic[i][1], j, tmp_c)
            ans += tmp_c
        # print(dic[i][1], A - tmp, min(B - tmp, dic[i][1]))
        print(ans)
    else:
        print(sum(v[:A])/A)
        # print(dic[i][1], A - tmp)
        print(int(kai[dic[i][1]] / kai[dic[i][1] - (A - tmp)] / kai[A - tmp]))

if __name__ == "__main__":
    main()

Submission status: Wrong Answer

Solution code:
import collections
import math
N,A,B  = map(int, input().split())
v = list(map(int,input().split()))

nums = collections.defaultdict(int)
for x in v:
    nums[x] += 1
ave = [[0 for i in range (B - A + 1)] for j in range(2)]
v.sort(reverse = True)
for i in range(A , B + 1):
    ave[0][i - A] = sum(v[:i]) / i
    ave[1][i - A] = v[:i]
    #print(ave)
ans = max(ave[0])
print(ans)
#ave[0] = list(map(str, ave[0]))

indexes = [i for i in range(B - A + 1) if ave[0][i] == ans]
max_counter = [] * len(indexes)
ans = 0
for i in indexes:
    counter = collections.Counter(ave[1][i])
    #print(counter)
    tmp_ans = 1
    for x in counter:
        #print(x)
        #print(nums[x])
        #print(counter[x])
        tmp_ans *= math.factorial(nums[x]) / math.factorial(counter[x]) / math.factorial(nums[x] - counter[x])
    ans += tmp_ans
print(int(ans))

Submission status: Wrong Answer

Solution code:
import collections
import math
N,A,B  = map(int, input().split())
v = list(map(int,input().split()))

nums = collections.defaultdict(int)
for x in v:
    nums[x] += 1
ave = [[0 for i in range (B - A + 1)] for j in range(2)]
v.sort(reverse = True)
for i in range(A , B + 1):
    ave[0][i - A] = sum(v[:i]) / i
    ave[1][i - A] = v[:i]
    #print(ave)
ans = max(ave[0])
print(ans)
#ave[0] = list(map(str, ave[0]))

indexes = [i for i in range(B - A + 1) if ave[0][i] == ans]
max_counter = [] * len(indexes)
ans = 0
for i in indexes:
    counter = collections.Counter(ave[1][i])
    #print(counter)
    tmp_ans = 1
    for x in counter:
        #print(x)
        #print(nums[x])
        #print(counter[x])
        tmp_ans *= int(math.factorial(nums[x]) / math.factorial(counter[x]) / math.factorial(nums[x] - counter[x]))
    ans += tmp_ans
print(ans)

Submission status: Wrong Answer

Solution code:
n,a,b=map(int,input().split())
v=[int(i) for i in input().split()]
v.sort()
v.reverse()
ans=0
from collections import Counter
c=Counter()
k=0
tmp=0
for i in range(n):
    if i<a-1:
        ans+=v[i]
    elif i==a-1:
        tmp=v[i]
        c[v[i]]+=1
        ans+=v[i]
    else:
        if tmp!=v[i]:
            break
        else:
            c[v[i]]+=1
            k+=1
ans=ans/a
print(ans)
def f(n,m):
    import math
    if n-m<0:
        return 0
    return(math.factorial(n)//math.factorial(n-m)//math.factorial(m))
ans2=0

if ans==tmp:
    for i in range(c[tmp]-k,c[tmp]-k+b-a+1):
        ans2+=f(c[tmp],i)
    print(ans2)
else:
    print(f(c[tmp],k))

Submission status: Wrong Answer

Solution code:
n,a,b=map(int,input().split())
v=[int(i) for i in input().split()]
v.sort()
v.reverse()
ans=0
from collections import Counter
c=Counter()
k=0
tmp=0
for i in range(n):
    if i<a-1:
        ans+=v[i]
    elif i==a-1:
        tmp=v[i]
        c[v[i]]+=1
        ans+=v[i]
    else:
        if tmp!=v[i]:
            break
        else:
            c[v[i]]+=1
            k+=1
ans=ans/a
print(ans)
def f(n,m):
    import math
    if n-m<0:
        return 0
    return(math.factorial(n)//math.factorial(n-m)//math.factorial(m))
ans2=0
"""if min(b-a,k)==0:
    k=1
    b+=1"""
if v[0]==tmp:
    for i in range(c[tmp]-k,c[tmp]-k+b-a+1):
        ans2+=f(c[tmp],i)
    print(ans2)
else:
    print(f(c[tmp],k))

Submission status: Wrong Answer

Solution code:
N, A, B = map(int, input().split())
val = [int(i) for i in input().split()]

def combi(n, m):
    from math import factorial
    return factorial(n) // (factorial(m) * factorial(n-m))

val.sort(reverse=True)
ave = sum(val[:A])/A

l = val.index(val[A-1])
x = val.count(val[A-1])
ct = 0

if val[0] == val[l]:
    for i in range(A-l, x+1):
        if A + i - 1 > B:
            break
        else:
            ct += combi(x, i)
else:
    ct += combi(x, A-l)
print(ave)
print(ct)

Submission status: Wrong Answer

Solution code:
import math
import sys
sys.setrecursionlimit(100000)
from functools import lru_cache

N,A,B = map(int, input().strip().split(' '))
V = sorted(list(map(int, input().strip().split(' '))), reverse=True)
max_sum = sum(V[:A])
print(max_sum/A)

@lru_cache(10000)
def factorial(n):
  if n == 0 or n == 1: return 1
  return n*factorial(n-1)

def Combination(n,r):
  return factorial(n) / factorial(r) / factorial(n-r)

n = V.count(V[A-1])
if V[0] == V[A-1]:
  ans = 0
  for r in range(A, min(B, n)+1):
    ans += Combination(n, r)
  print(int(ans))
else:
  print(int(Combination(n, V[:A].count(V[A-1]))))

Submission status: Wrong Answer

Solution code:
import math
import sys
sys.setrecursionlimit(100000)
from functools import lru_cache

N,A,B = map(int, input().strip().split(' '))
V = sorted(list(map(int, input().strip().split(' '))), reverse=True)
max_sum = sum(V[:A])
print(max_sum/A)

@lru_cache(2000)
def factorial(n):
  if n == 0 or n == 1: return 1
  return n*factorial(n-1)

def Combination(n,r):
  return factorial(n) / factorial(r) / factorial(n-r)

n = V.count(V[A-1])
if V[0] == V[A-1]:
  ans = 0
  for r in range(A, min(B, n)+1):
    ans += Combination(n, r)
  print(int(ans))
else:
  print(int(Combination(n, V[:A].count(V[A-1]))))

Submission status: Wrong Answer

Solution code:
import math
import sys
sys.setrecursionlimit(100000)
from functools import lru_cache

N,A,B = map(int, input().strip().split(' '))
V = sorted(list(map(int, input().strip().split(' '))), reverse=True)
max_sum = sum(V[:A])
print(max_sum/A)

@lru_cache(2000)
def factorial(n):
  if n == 0 or n == 1: return 1
  return n*factorial(n-1)

def Combination(n,r):
  return factorial(n) / factorial(r) / factorial(n-r)

if V[0] == V[A-1]:
  ans = 0
  n = V.count(V[0])
  for r in range(A, n+1):
    ans += Combination(n, r)
  print(int(ans))
else:
  print(int(Combination(V.count(V[A-1]), V[:A].count(V[A-1]))))

Submission status: Wrong Answer

Solution code:
import math
import sys
sys.setrecursionlimit(100000)
from functools import lru_cache

N,A,B = map(int, input().strip().split(' '))
V = sorted(list(map(int, input().strip().split(' '))))
max_sum = sum(V[-A:])
print(max_sum/A)

@lru_cache(2000)
def factorial(n):
  if n == 0 or n == 1: return 1
  return n*factorial(n-1)

def Combination(n,r):
  return factorial(n) / factorial(r) / factorial(n-r)

if min(V) == max(V):
  ans = 0
  for r in range(A, B+1):
    ans += Combination(N, r)
  print(int(ans))
else:
  print(int(Combination(V.count(V[-A]), V[-A:].count(V[-A]))))