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: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace lec15B.cs
{
    class Program
    {

        static void Main(string[] args)
        {

            int n = 0, w = 0;


            string input = Console.ReadLine();
            string[] split = input.Split(' ');

            n = int.Parse(split[0]);
            w = int.Parse(split[1]);

            int[,] array = new int[n, 3];
            //double[] highvalue = new double[n];

            for (int i = 0; i < n; i++)
            {
                input = Console.ReadLine();
                split = input.Split(' ');

                array[i, 0] = int.Parse(split[0]);
                array[i, 1] = int.Parse(split[1]);

                //highvalue[i] = array[i, 0] / array[i, 1];

                //Console.WriteLine(array[i, 0]);
                //Console.WriteLine(array[i, 1]);
                //Console.WriteLine(highvalue[i]);
            }

            MergeSort(array, 0, n -1);

            /*
            double tmpvalue;
            int tmpv, tmpw;
            bool flag = true;
            while (flag)
            {
                flag = false;
                for (int i = n - 1; i >= 1; i--)
                {
                    if (highvalue[i] > highvalue[i-1])
                    {
                        tmpvalue = highvalue[i]; highvalue[i] = highvalue[i-1]; highvalue[i-1] = tmpvalue;
                        tmpv = array[i, 0]; array[i, 0] = array[i-1, 0]; array[i-1, 0] = tmpv;
                        tmpw = array[i, 1]; array[i, 1] = array[i - 1, 1]; array[i-1, 1] = tmpw;

                        //Console.WriteLine(i);
                        //Console.WriteLine(array[i, 0]);
                        //Console.WriteLine(array[i, 1]);
                        //Console.WriteLine(highvalue[i]);

                        flag = true;
                    }
                }
            }*/

            double output = 0.0;
            int j = 0;
            while (w > 0 && j < n)
            {
                if (array[j,1] > w)
                {
                    output += (double)array[j, 0] * w / array[j, 1];
                    w -= array[j, 1];
                }
                else
                {
                    output += (double)array[j, 0];
                    w -= array[j, 1];
                }
                j++;
            }
            //string outputs = output.ToString("F0");
            // Console.WriteLine(input);
            //Console.WriteLine(split[0]);
            Console.WriteLine("{0:f8}",output);

            Console.ReadLine();

        }

        static void MergeSort (int [,] A,int left ,int right )
        {
            if ( left + 1 < right)
            {
                int mid = (left + right) / 2;
                MergeSort(A, left,mid );
                MergeSort(A, mid, right );
                Merge(A, left, mid, right );
            }
            return;
        }

        static void Merge(int [,] A , int left ,int mid ,int right) 
        {
            int n1 = mid - left;
            int n2 = right - mid;
            int[,] L = new int[n1,2];
            int[,] R = new int[n2,2];
            int i = 0;

            for ( i= 0; i < n1; i++)
            {
                L[i,0] = A[left + i,0];
                L[i,1] = A[left + i,1];
            }
            for ( i = 0; i < n2; i++)
            {
                R[i,0] = A[mid + i,0];
                R[i,1] = A[mid + i,1];
            }

            //L[n1] = 1000000000;
            //R[n2] = 1000000000;

            i = 0; int j = 0;

            for (int k= left; k < right; k++)
            {
                if (i == n1)
                {
                    A[k,0] = R[j,0];
                    A[k, 1] = R[j, 1];
                    j++;
                }
                else if(j == n2)
                {
                    A[k,0] = L[i,0];
                    A[k, 1] = L[i, 1];
                    i++;
                }
                else if ((double)L[i,0] / L[i,1] >=(double) R[j,0] /R[j,1])
                {
                    A[k, 0] = L[i, 0];
                    A[k, 1] = L[i, 1];
                    i++;
                }
                else
                {
                    A[k, 0] = R[j, 0];
                    A[k, 1] = R[j, 1];
                    j++;
                }
            }
            return;
        }
    }
}