Problem:
Score: 400 points

Problem Statement

We have N integers A_1, A_2, ..., A_N.

There are \frac{N(N-1)}{2} ways to choose two of them and form a pair. If we compute the product of each of those pairs and sort the results in ascending order, what will be the K-th number in that list?

Constraints

All values in input are integers.

2 \leq N \leq 2 \times 10^5

1 \leq K \leq \frac{N(N-1)}{2}

-10^9 \leq A_i \leq 10^9\ (1 \leq i \leq N)

Input

Input is given from Standard Input in the following format:

N K
A_1 A_2 \dots A_N

Output

Print the answer.

Sample Input 1

4 3
3 3 -4 -2

Sample Output 1

-6

There are six ways to form a pair. The products of those pairs are 9, -12, -6, -12, -6, 8.

Sorting those numbers in ascending order, we have -12, -12, -6, -6, 8, 9. The third number in this list is -6.

Sample Input 2

10 40
5 4 3 2 -1 0 0 0 0 0

Sample Output 2

6

Sample Input 3

30 413
-170202098 -268409015 537203564 983211703 21608710 -443999067 -937727165 -97596546 -372334013 398994917 -972141167 798607104 -949068442 -959948616 37909651 0 886627544 -20098238 0 -948955241 0 -214720580 277222296 -18897162 834475626 0 -425610555 110117526 663621752 0

Sample Output 3

448283280358331064

Solution in Fortran (gfortran v4.8.4) (judge verdict: Wrong Answer)

program main
  implicit none
  integer(8) :: n, k, mi, ma, md, i, x, y, z, negs, zeros, poss
  integer(8), allocatable :: a(:)
  read (*, *) n, k
  allocate (a(n))
  read (*, *) a(:)
  call quicksort(a)
  call count_pairs(a, n, negs, zeros, poss, x, y, z)
  if (negs < k .and. k <= negs + zeros) then  ! Zero
    write (*, "(i0)") 0
  else
    mi = -2 * 10_8 ** 18  ! Not large enough
    ma = 2 * 10_8 ** 18  ! Large enough
    do i = 1, 200
      md = mi + (ma - mi) / 2
      if (m_is_large_enough(md, k, n, a, negs, x)) then
        ma = md
      else
        mi = md
      end if
    end do
    write (*, "(i0)") ma
  end if

  contains

  logical function m_is_large_enough(m, k, n, a, negs, x)
    integer(8), intent(in) :: n, k, m, a(n), x, negs
    integer(8) :: cnt
    if (k <= negs) then  ! Negative
      cnt = shakutori_n(x, z, a(1:x), a(x + y + 1:n), m)
    else
      cnt = 0  ! ttk shakutori_p(a(1:x), a(x + y + 1:n), m)
    end if
    m_is_large_enough = (cnt >= k)
  end function m_is_large_enough

  integer(8) function shakutori_n(x, z, negs, poss, m)
    integer(8), intent(in) :: x, z, negs(x), poss(z), m
    integer(8) :: p1, p2
    ! Count combinations no more than m
    shakutori_n = 0
    p2 = z + 1
    outer: do p1 = 1, x
      do while (negs(p1) * poss(p2 - 1) > m)
        p2 = p2 - 1
        if (p2 <= 1) exit outer
      end do
      shakutori_n = shakutori_n + p2 - 1
    end do outer
  end function shakutori_n

  recursive subroutine quicksort(a)
    integer(8), intent(inout) :: a(:)
    integer(8) :: pivot, i, j, k, tmp, n
    real(4) :: r
    n = size(a)
    if (n <= 1) return
    i = 1
    j = n
    call random_number(r)
    k = 1 + floor(r * n)
    k = max(1, min(k, n))
    pivot = a(k)
    do
      do while (.not. pivot <= a(i))
        i = i + 1
      end do
      do while (.not. a(j) <= pivot)
        j = j - 1
      end do
      if (i >= j) exit
      tmp = a(i)
      a(i) = a(j)
      a(j) = tmp
      i = i + 1
      j = j - 1
    end do
    call quicksort(a(1:i - 1))
    call quicksort(a(j + 1:n))
  end subroutine quicksort

  subroutine count_pairs(a, n, negs, zeros, poss, nega, zeroa, posa)
    integer(8), intent(in) :: n, a(n)
    integer(8), intent(out) :: negs, zeros, poss, nega, zeroa, posa
    integer(8) :: i
    do i = 1, n
      if (a(i) < 0) nega = i
      if (a(i) <= 0) zeroa = i
    end do
    posa = n - zeroa
    zeroa = zeroa - nega
    negs = nega * posa
    zeros = zeroa * (posa + nega) + (zeroa * (zeroa - 1)) / 2
    poss = (n * (n - 1)) / 2 - negs - zeros
  end subroutine count_pairs
end program main