open System
open System.Collections.Generic

module InputUtility =
    let InputTokens = new Queue<string>()

    let EnsureInput () =
        if InputTokens.Count = 0 then
            let input = Console.ReadLine ()
            let s = input.Split ([|' '|], StringSplitOptions.RemoveEmptyEntries)
            if s.Length > 0 then
                for x in s do InputTokens.Enqueue(x)
                true
            else false
        else true

    let rec ReadNext () =
        if EnsureInput () then InputTokens.Dequeue ()
        else ReadNext ()

    let ReadNextInt () = ReadNext () |> int

    let Read2Int () = ReadNextInt (), ReadNextInt ()

    let ReadListOf f n =
        let rec loop acc = function
            | 0 -> List.rev acc
            | c -> loop ((ReadNext () |> f) :: acc) (c-1)
        loop [] n

    let MultipleCaseWithId f =
        let caseNum = ReadNextInt ()
        let rec loop index =
            if index = caseNum then ()
            else
                f index
                loop (index + 1)
        loop 0

    let MultipleCase f = MultipleCaseWithId (fun _ -> f ())

    let ReadList n =
        let rec loop acc = function
            | 0 -> List.rev acc
            | c -> loop (ReadNext () :: acc) (c-1)
        loop [] n

open InputUtility

module ARC075 =
    let rec binarySearchInt64 f s t =
        if s+1L=t then s
        else
            let d = (s+t)/2L
            if f d then binarySearchInt64 f d t
            else binarySearchInt64 f s d

    let private Widespread () =
        let g64 = ReadNext >> int64
        let ubDiv a b = (a - 1L) / b + 1L
        let n = ReadNextInt ()
        let inA, b = g64 (), g64 ()
        let a = inA - b
        let h = ReadListOf int64 n
        let f inD =
            let d = inD - 1L
            let bd = d * b
            let rec inner c = function
                | [] -> c >= 0L
                | h :: t ->
                    if h <= bd then inner c t
                    elif c < 0L then false
                    else
                        let r = ubDiv (h - bd) a
                        inner (c - r) t
            inner d h |> not
        binarySearchInt64 f 1L (h |> Seq.sum)
        |> printfn "%d"

    let Entry = Widespread

ARC075.Entry ()