

# -*- coding: utf-8 -*-

import bisect

import heapq

import math

import random

import sys

from pprint import pprint

from collections import Counter, defaultdict, deque

from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal

from functools import lru_cache, reduce

from itertools import combinations, combinations_with_replacement, product, permutations

from operator import add, mul



sys.setrecursionlimit(10000)





def read_int():

    return int(input())





def read_int_n():

    return list(map(int, input().split()))





def read_float():

    return float(input())





def read_float_n():

    return list(map(float, input().split()))





def read_str():

    return input().strip()





def read_str_n():

    return list(map(str, input().split()))





def error_print(*args):

    print(*args, file=sys.stderr)





def mt(f):

    import time



    def wrap(*args, **kwargs):

        s = time.time()

        ret = f(*args, **kwargs)

        e = time.time()



        error_print(e - s, 'sec')

        return ret



    return wrap





def Prim(g):

    V = list(g.keys())

    for v in g.values():

        V.extend(list(v.keys()))

    V = list(set(V))



    used = set([])

    q = []

    heapq.heappush(q, (0, V[0]))



    ret = 0

    while q:

        c, v = heapq.heappop(q)



        if v in used:

            continue

        used.add(v)

        ret += c

        for u in g[v]:

            heapq.heappush(q, (g[v][u], u))

    return ret





@mt

def slv(N, A, B, H):

    H.sort(reverse=True)



    def e(t):

        b = B*t

        a = A-B

        for h in H:

            h -= b

            if h > 0:

                t -= int(math.ceil(h/a))

        return t >= 0



    l = 0

    r = max(H)

    while r - l > 1:

        m = (r+l)//2

        if e(m):

            r = m

        else:

            l = m



    return r





def main():

    N, A, B = read_int_n()

    H = [read_int() for _ in range(N)]



    print(slv(N, A, B, H))





if __name__ == '__main__':

    main()

# -*- coding: utf-8 -*-

import bisect

import heapq

import math

import random

from collections import Counter, defaultdict, deque

from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal

from fractions import Fraction

from functools import lru_cache, reduce

from itertools import combinations, combinations_with_replacement, product, permutations, accumulate

from operator import add, mul, sub, itemgetter, attrgetter





import sys

# sys.setrecursionlimit(10**6)

# readline = sys.stdin.buffer.readline

readline = sys.stdin.readline



INF = 2**62-1





def read_int():

    return int(readline())





def read_int_n():

    return list(map(int, readline().split()))





def read_float():

    return float(readline())





def read_float_n():

    return list(map(float, readline().split()))





def read_str():

    return readline().strip()





def read_str_n():

    return readline().strip().split()





def ep(*args):

    print(*args, file=sys.stderr)





def mt(f):

    import time



    def wrap(*args, **kwargs):

        s = time.perf_counter()

        ret = f(*args, **kwargs)

        e = time.perf_counter()



        ep(e - s, 'sec')

        return ret



    return wrap





class Bisect:

    def __init__(self, func):

        self.__func = func



    def bisect_left(self, x, lo, hi):

        while lo < hi:

            mid = (lo+hi)//2

            if self.__func(mid) < x:

                lo = mid+1

            else:

                hi = mid

        return lo



    def bisect_right(self, x, lo, hi):

        while lo < hi:

            mid = (lo+hi)//2

            if x < self.__func(mid):

                hi = mid

            else:

                lo = mid+1

        return lo



@mt

def slv(N, A, B, H):

    c = A-B

    def f(n):

        m = n

        for h in H:

            h -= n * B

            if h > 0:

                m -= -(-h // c)

        return 1 if m >= 0 else 0



    return Bisect(f).bisect_left(1, 0, 10**9)







def main():

    N, A, B = read_int_n()

    H = [read_int() for _ in range(N)]

    print(slv(N, A, B, H))





if __name__ == '__main__':

    main()

# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from pprint import pprint
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul

sys.setrecursionlimit(10000)


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()
        error_print(e - s, "sec")
        return ret

    return wrap


def Prim(g):
    V = list(g.keys())
    for v in g.values():
        V.extend(list(v.keys()))
    V = list(set(V))
    used = set([])
    q = []
    heapq.heappush(q, (0, V[0]))
    ret = 0
    while q:
        c, v = heapq.heappop(q)
        if v in used:
            continue
        used.add(v)
        ret += c
        for u in g[v]:
            heapq.heappush(q, (g[v][u], u))
    return ret


@mt
def slv(N, A, B, H):
    H.sort(reverse=True)

    def e(t):
        b = B * t
        a = A - B
        for h in H:
            h -= b
            if h > 0:
                t -= int(math.ceil(h / a))
        return t >= 0

    l = 0
    r = max(H)
    while r - l > 1:
        m = (r + l) // 2
        if e(m):
            r = m
        else:
            l = m
    return r


def main():
    N, A, B = read_int_n()
    H = [read_int() for _ in range(N)]
    print(slv(N, A, B, H))


if __name__ == "__main__":
    main()

# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import (
    combinations,
    combinations_with_replacement,
    product,
    permutations,
    accumulate,
)
from operator import add, mul, sub, itemgetter, attrgetter
import sys

# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 2**62 - 1


def read_int():
    return int(readline())


def read_int_n():
    return list(map(int, readline().split()))


def read_float():
    return float(readline())


def read_float_n():
    return list(map(float, readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()


def ep(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.perf_counter()
        ret = f(*args, **kwargs)
        e = time.perf_counter()
        ep(e - s, "sec")
        return ret

    return wrap


class Bisect:
    def __init__(self, func):
        self.__func = func

    def bisect_left(self, x, lo, hi):
        while lo < hi:
            mid = (lo + hi) // 2
            if self.__func(mid) < x:
                lo = mid + 1
            else:
                hi = mid
        return lo

    def bisect_right(self, x, lo, hi):
        while lo < hi:
            mid = (lo + hi) // 2
            if x < self.__func(mid):
                hi = mid
            else:
                lo = mid + 1
        return lo


@mt
def slv(N, A, B, H):
    c = A - B

    def f(n):
        m = n
        for h in H:
            h -= n * B
            if h > 0:
                m -= -(-h // c)
        return 1 if m >= 0 else 0

    return Bisect(f).bisect_left(1, 0, 10**9)


def main():
    N, A, B = read_int_n()
    H = [read_int() for _ in range(N)]
    print(slv(N, A, B, H))


if __name__ == "__main__":
    main()

-import sys -from pprint import pprint +from fractions import Fraction -from itertools import combinations, combinations_with_replacement, product, permutations -from operator import add, mul +from itertools import ( +    combinations, +    combinations_with_replacement, +    product, +    permutations, +    accumulate, +) +from operator import add, mul, sub, itemgetter, attrgetter +import sys -sys.setrecursionlimit(10000) +# sys.setrecursionlimit(10**6) +# readline = sys.stdin.buffer.readline +readline = sys.stdin.readline +INF = 2**62 - 1 -    return int(input()) +    return int(readline()) -    return list(map(int, input().split())) +    return list(map(int, readline().split())) -    return float(input()) +    return float(readline()) -    return list(map(float, input().split())) +    return list(map(float, readline().split())) -    return input().strip() +    return readline().strip() -    return list(map(str, input().split())) +    return readline().strip().split() -def error_print(*args): +def ep(*args): -        s = time.time() +        s = time.perf_counter() -        e = time.time() -        error_print(e - s, "sec") +        e = time.perf_counter() +        ep(e - s, "sec") -def Prim(g): -    V = list(g.keys()) -    for v in g.values(): -        V.extend(list(v.keys())) -    V = list(set(V)) -    used = set([]) -    q = [] -    heapq.heappush(q, (0, V[0])) -    ret = 0 -    while q: -        c, v = heapq.heappop(q) -        if v in used: -            continue -        used.add(v) -        ret += c -        for u in g[v]: -            heapq.heappush(q, (g[v][u], u)) -    return ret +class Bisect: +    def __init__(self, func): +        self.__func = func + +    def bisect_left(self, x, lo, hi): +        while lo < hi: +            mid = (lo + hi) // 2 +            if self.__func(mid) < x: +                lo = mid + 1 +            else: +                hi = mid +        return lo + +    def bisect_right(self, x, lo, hi): +        while lo < hi: +            mid = (lo + hi) // 2 +            if x < self.__func(mid): +                hi = mid +            else: +                lo = mid + 1 +        return lo -    H.sort(reverse=True) +    c = A - B -    def e(t): -        b = B * t -        a = A - B +    def f(n): +        m = n -            h -= b +            h -= n * B -                t -= int(math.ceil(h / a)) -        return t >= 0 +                m -= -(-h // c) +        return 1 if m >= 0 else 0 -    l = 0 -    r = max(H) -    while r - l > 1: -        m = (r + l) // 2 -        if e(m): -            r = m -        else: -            l = m -    return r +    return Bisect(f).bisect_left(1, 0, 10**9)