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 C# (Mono 4.6.2.0) (judge verdict: Time Limit Exceeded)

using System;
using System.Collections.Generic;
using System.Linq;

namespace Atcoder
{
    class Program
    {
        static void Main(string[] args)
        {
            var n = ReadLineLongSpilit();
            var h = ReadLineLongSpilit();
            long re = 0;

            h = h.OrderBy(x => -x).ToArray();

            for (int i = 0; i < n[0]; i++) {
                if(h[i] == h.Max() && n[1] > 0) {
                    n[1]--;
                    h[i] = 0;
                    continue;
                }
                re += h[i];
            }

            Console.WriteLine(re);
            ReadLine();

        }

        //メモ

        //アルゴリズム

        //・全探索解

        /*
         * 例 [A, B, C]
         *
         *  A - B, A - C
         *  B - C
         * 
         *   for (int i = 0; i < n; i++) {
         *  
         *       for (int j = i + 1; j < n; j++) {
         *
         *           array[i], array[j]
         *
         *       }
         *   }
         */

        // ・配列の前後を見る

        /*
         *  例 array[1, 2, 3, 4, 5]
         *  
         *  r = 3;
         * 
         *  array[i - 1] => 1
         *  array[i] => 2
         *  array[i + 1] => 3
         * 
         * //範囲
         * int r = 3;
         * 
         * for(int i = 1; i <= array.Length - r; i++) { }
         * 
         */

        //配列 --------------------

        //降順
        //var sort = array.OrderBy(x => -x).ToArray();

        //合計値
        //array.Sum();

        //最大値
        //List.Sort(); List[Count() - 1] 

        //連続の整数配列を作成
        //
        // 1, 2, 3, 4, 5,..., n
        //var continuous = Enumerable.Range(1, n).ToList();

        //--------------------

        //切り捨て

        //double d = Math.Floor(n);

        //切り上げ

        //double d = Math.Celling(n);

        //kのn乗
        //(int) Math.Pow(k, n);

        //for文の逆
        //for(int i = array.Length - 1; i >= 0; i--) { }


        /// <summary>
        /// 最大公約数
        /// </summary>
        static int gcd(int a, int b)
        {
            if (a > b) {
                return gcd(b, a);
            }

            while (b != 0) {
                var remainder = a % b;
                a = b;
                b = remainder;
            }

            return a;
        }

        //最小公倍数
        static int lcm(int a, int b) => a * b / gcd(a, b);

        /// <summary>
        /// コンビネーション
        /// </summary>
        static int nCm(int n, int m)
        {
            if (m == 0) return 1;
            if (n == 0) return 0;
            return n * nCm(n - 1, m - 1) / m;
        }

        /// <summary>
        /// 数字配列の重複をカウント
        /// </summary>
        public static int DistinctInt(IEnumerable<int> array)
        {
            var q = array.Distinct().Count();
            return array.Count() - q;
        }

        /// <summary>
        /// 文字配列の重複をカウント
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public static int DistinctString(IEnumerable<string> array)
        {
            var q = array.Distinct().Count();
            return array.Count() - q;
        }

        public static string ReadLine() => Console.ReadLine();
        public static int ReadLineInt() => int.Parse(Console.ReadLine());
        public static long ReadLineLongInt() => long.Parse(Console.ReadLine());
        public static string[] ReadLineStringSplit(char a = ' ') => ReadLine().Split(a).ToArray();
        public static int[] ReadLineIntSpilit(char a = ' ') => ReadLine().Split(a).Select(x => int.Parse(x)).ToArray();
        public static long[] ReadLineLongSpilit(char a = ' ') => ReadLine().Split(a).Select(x => long.Parse(x)).ToArray();
        static string[] GetAlphaLowerArray() => new string[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" };
        static string[] GetAlphaUpperArray() => new string[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" };
    }
}