杭电1009_FatMouse' Trade——java

Problem Description

FatMouse prepared M pounds of cat food, ready to trade with the cats guarding the warehouse containing his favorite food, JavaBean.
The warehouse has N rooms. The i-th room contains J[i] pounds of JavaBeans and requires F[i] pounds of cat food. FatMouse does not have to trade for all the JavaBeans in the room, instead, he may get J[i]* a% pounds of JavaBeans if he pays F[i]* a% pounds of cat food. Here a is a real number. Now he is assigning this homework to you: tell him the maximum amount of JavaBeans he can obtain.

 

Input

The input consists of multiple test cases. Each test case begins with a line containing two non-negative integers M and N. Then N lines follow, each contains two non-negative integers J[i] and F[i] respectively. The last test case is followed by two -1's. All integers are not greater than 1000.

 

Output

For each test case, print in a single line a real number accurate up to 3 decimal places, which is the maximum amount of JavaBeans that FatMouse can obtain.

 

Sample Input

5 3

7 2

4 3

5 2

20 3

25 18

24 15

15 10

-1 -1

 

Sample Output

13.333

31.500

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    private static class Node {
        double j;
        double f;
        double jf;
    }

    private static class Reader {
        static BufferedReader reader;
        static StringTokenizer tokenizer;

        /**
         * call this method to initialize reader for InputStream
         */
        static void init(InputStream input) {
            reader = new BufferedReader(
                    new InputStreamReader(input));
            tokenizer = new StringTokenizer("");
        }

        /**
         * get next word
         */
        static String next() throws IOException {
            while (!tokenizer.hasMoreTokens()) {
                //TODO add check for eof if necessary
                tokenizer = new StringTokenizer(
                        reader.readLine());
            }
            return tokenizer.nextToken();
        }

        static int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        static double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }
    }

    public static void main(String[] args) {
        try {
            Reader.init(System.in);
            while (true) {
                int m = Reader.nextInt();
                int n = Reader.nextInt();
                if (n == -1 && m == -1) {
                    break;
                }
                List<Node> list = new ArrayList<Node>();
                for(int i = 1;i <= n;i++){
                    Node node = new Node();
                    node.j = Reader.nextDouble();
                    node.f = Reader.nextDouble();
                    node.jf = node.j/node.f;
                    list.add(node);
                }
                Collections.sort(list, new Comparator<Node>() {
                    @Override
                    public int compare(Node o1, Node o2) {
                        if(o2.jf > o1.jf){
                            return 1;
                        }
                        else if(o2.jf < o1.jf){
                            return -1;
                        }
                        else
                            return 0;
                    }
                });
                double count = 0 ;
                for(int i = 0; i < list.size();i++){
                    Node node = list.get(i);
                    if(m <= 0)
                        break;
                    else{
                        if(m - node.f >= 0){
                            count += node.j;
                            m -= node.f;
                        }
                        else{
                            count += m/node.f*node.j;
                            m = 0;
                        }
                    }
                }
                System.out.printf("%.3f\r\n",count);
            }
        }catch (Exception e){

        }
    }
}