Problem:
Fractional Knapsack Problem

You have $N$ items that you want to put them into a knapsack of capacity $W$. Item $i$ ($1 \le i \le N$) has weight $w_i$ and value $v_i$ for the weight.

When you put some items into the knapsack, the following conditions must be satisfied:

The total value of the items is as large as possible.

The total weight of the selected items is at most $W$.

You can break some items if you want. If you put $w'$($0 \le w' \le w_i$) of item $i$, its value becomes $\displaystyle v_i \times \frac{w'}{w_i}.$

Find the maximum total value of items in the knapsack.

Input

$N$ $W$
$v_1$ $w_1$
$v_2$ $w_2$
:
$v_N$ $w_N$

The first line consists of the integers $N$ and $W$. In the following $N$ lines, the value and weight of the $i$-th item are given.

Output

Print the maximum total value of the items in a line. The output must not contain an error greater than $10^{-6}$.

Constraints

$1 \le N \le 10^5$

$1 \le W \le 10^9$

$1 \le v_i \le 10^9 (1 \le i \le N)$

$1 \le w_i \le 10^9 (1 \le i \le N)$

Sample Input 1

3 50
60 10
100 20
120 30

Sample Output 1

240

When you put 10 of item $1$, 20 of item $2$ and 20 of item $3$, the total value is maximized.

Sample Input 2

3 50
60 13
100 23
120 33

Sample Output 2

210.90909091

When you put 13 of item $1$, 23 of item $2$ and 14 of item $3$, the total value is maximized. Note some outputs can be a real number.

Sample Input 3

1 100
100000 100000

Sample Output 3

100

Solution in C# (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CompProgLib;

namespace ALDS1_15_B
{
    public class Program

    {
        public struct Node:IComparable<Node>
        {
            public int Value { get; private set; }
            public int Weight { get; private set; }
            public double ValuePerWaight { get; private set; }

            public Node(int v,int w)
            {
                Value = v;
                Weight = w;
                ValuePerWaight = v / (double)w;
            }

            public int CompareTo(Node other)
            {
                if (ValuePerWaight - other.ValuePerWaight > 0)
                {
                    return 1;
                }
                else if (ValuePerWaight - other.ValuePerWaight < 1)
                {
                    return -1;
                }
                else { return 0; }
            }
        }

        public static void Main(string[] args)
        {
            int[] line = ReadIntAr();
            PriorityQueue<Node> pq = new PriorityQueue<Node>();

            for (int i = 0 ; i < line[0] ; i++)
            {
                int[] item = ReadIntAr();
                pq.Enqueue(new Node(item[0], item[1]));
            }

            int CurrentWeight = 0;
            decimal CurrentValue = 0;

            while (pq.Count > 0)
            {
                Node tmp = pq.Dequeue();

                if (CurrentWeight + tmp.Weight <= line[1])
                {
                    CurrentWeight += tmp.Weight;
                    CurrentValue += tmp.Value;
                }
                else
                {
                    int remainingWeight = line[1] - CurrentWeight;
                    CurrentWeight += remainingWeight;
                    CurrentValue += (decimal)tmp.ValuePerWaight * remainingWeight;
                    break;
                }            
            }
            Console.WriteLine(CurrentValue.ToString("F8"));
        }

        static string ReadSt() { return Console.ReadLine(); }
        static int ReadInt() { return int.Parse(Console.ReadLine()); }
        static long ReadLong() { return long.Parse(Console.ReadLine()); }
        static double ReadDouble() { return double.Parse(Console.ReadLine()); }
        static string[] ReadStAr(char sep = ' ') { return Console.ReadLine().Split(sep); }
        static int[] ReadIntAr(char sep = ' ') { return Array.ConvertAll(Console.ReadLine().Split(sep), e => int.Parse(e)); }
        static long[] ReadLongAr(char sep = ' ') { return Array.ConvertAll(Console.ReadLine().Split(sep), e => long.Parse(e)); }
        static double[] ReadDoubleAr(char sep = ' ') { return Array.ConvertAll(Console.ReadLine().Split(sep), e => double.Parse(e)); }

    }

}

namespace CompProgLib
{
    public class PriorityQueue<T> where T : IComparable<T>

    {

        private List<T> Buffer { get; set; }

        public int Count { get { return Buffer.Count; } }

        public PriorityQueue() { Buffer = new List<T>(); }
        public PriorityQueue(int capacity) { Buffer = new List<T>(capacity); }


        /// <summary>
        /// ヒープ化されている配列リストに新しい要素を追加する。
        /// </summary>
        public void Enqueue(T item)
        {
            int n = Buffer.Count;
            Buffer.Add(item);

            while (n != 0)
            {
                int i = (n - 1) / 2;
                if (Buffer[n].CompareTo(Buffer[i]) > 0)
                {
                    T tmp = Buffer[n]; Buffer[n] = Buffer[i]; Buffer[i] = tmp;
                }
                n = i;
            }
        }

        /// <summary>
        /// ヒープから最大値を取り出し、削除する。
        /// </summary>
        public T Dequeue()
        {
            T ret = Buffer[0];
            int n = Buffer.Count - 1;
            Buffer[0] = Buffer[n];
            Buffer.RemoveAt(n);

            for (int i = 0, j ; (j = 2 * i + 1) < n ;)
            {
                if ((j != n - 1) && (Buffer[j].CompareTo(Buffer[j + 1]) < 0))
                    j++;
                if (Buffer[i].CompareTo(Buffer[j]) < 0)
                {
                    T tmp = Buffer[j]; Buffer[j] = Buffer[i]; Buffer[i] = tmp;
                }
                i = j;
            }
            return ret;
        }

        /// <summary>
        /// ヒープから最大値を参照する。
        /// </summary>
        public T Peek()
        {
            if (Count == 0) throw new InvalidOperationException();
            return this.Buffer[0];
        }
    }
}