Problem:
Score : 300 points

Problem Statement

Fennec is fighting with N monsters.

The health of the i-th monster is H_i.

Fennec can do the following two actions:

Attack: Fennec chooses one monster. That monster's health will decrease by 1.

Special Move: Fennec chooses one monster. That monster's health will become 0.

There is no way other than Attack and Special Move to decrease the monsters' health.

Fennec wins when all the monsters' healths become 0 or below.

Find the minimum number of times Fennec needs to do Attack (not counting Special Move) before winning when she can use Special Move at most K times.

Constraints

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

0 \leq K \leq 2 \times 10^5

1 \leq H_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K
H_1 ... H_N

Output

Print the minimum number of times Fennec needs to do Attack (not counting Special Move) before winning.

Sample Input 1

3 1
4 1 5

Sample Output 1

5

By using Special Move on the third monster, and doing Attack four times on the first monster and once on the second monster, Fennec can win with five Attacks.

Sample Input 2

8 9
7 9 3 2 3 8 4 6

Sample Output 2

0

She can use Special Move on all the monsters.

Sample Input 3

3 0
1000000000 1000000000 1000000000

Sample Output 3

3000000000

Watch out for overflow.

Solution in Fortran (gfortran v4.8.4) (judge verdict: Runtime Error)

module priority_queue_modules
implicit none
integer(8), pointer:: array(:)
contains

subroutine build_heap(original)
    integer(8):: original(:)
    
    allocate(array(size(original)))
    array(:) = original(:)
    call build_max_heap()
end subroutine

recursive subroutine max_heapify(index)
    integer(8)::rc, lc, self
    integer(4):: index
    
    rc = array(index*2)
    lc = array(index*2+1)
    self = array(index)

    if (self > max(rc,lc)) return
    if (index*2 > size(array)) return
    if (index*2+1 > size(array)) lc = -1 

    if (rc >= lc)then
        array(index) = rc
        array(index*2) = self
        call max_heapify(index*2)
    else
        array(index) = lc
        array(index*2+1) = self
        call max_heapify(index*2+1)
    end if
end subroutine

subroutine build_max_heap()
    integer(4):: i
    
    do i = size(array)/2, 1, -1
        call max_heapify(i)
    end do
end subroutine

function pop_max_heap() result(ret)
    integer(8)::ret
    integer(8), pointer:: tmp(:)
    
    ret = array(1)
    array(1) = array(size(array))
    allocate(tmp(size(array)-1))
    tmp(:) = array(:size(array)-1)
    deallocate(array)
    allocate(array(size(tmp(:))))
    array(:) = tmp(:)
    deallocate(tmp)
    call max_heapify(1)
end function

function can_pop() result(ret)
    logical:: ret
    if (size(array) >= 1)then
        ret = .true.
    else
        ret = .false.
    end if
end function

end module


program main
    use priority_queue_modules, only: build_heap, pop_max_heap, can_pop
    implicit none
    integer(8), allocatable:: h(:), sorted_h(:)
    integer(4):: n, k, i

    read*, n, k
    allocate(h(n), sorted_h(n))
    read*, h(:)
    call build_heap(h(:))
    deallocate(h)

    do i=1, size(sorted_h(:))
        sorted_h(i) = pop_max_heap()
    end do

    print"(i0)", sum(sorted_h(k+1:))

end program main