Java语言如何在PAT中减少用时

例如PAT1020 月饼，此题需采用一些循环，且接受字符串较多，故耗时较大。而接收方式若设定为Scanner则很容易超时，代码如下：

import java.util.Scanner;

public class Main{

    public static void main(String[] args) {
        //1.接收第一行的种类数N与市场最大需求D
        Scanner scanner = new Scanner(System.in);
        String line = scanner.nextLine();
        String[] split = line.split("\s+");
        int N = Integer.parseInt(split[0]);
        int D = Integer.parseInt(split[1]);
        
        //2.接收第二行的N中月饼的含有量  —— 放入数组中   mooncakes[]
        String line2 = scanner.nextLine();
        double[] mooncakes = new double[N];
        String[] split1 = line2.split("\s+");int m = 0;
        for (String o : split1) {
            mooncakes[m] = Double.parseDouble(o);
            m++;
            //System.out.println(o);
        }

        //3.接受第三行的对应月饼总售价   ——  放入另一个整型数组中 price[]
        String line3 = scanner.nextLine();
        double[] price = new double[N];int j = 0;
        String[] split2 = line3.split("\s+");
        for (String o : split2) {
            price[j] = Double.parseDouble(o);
            j++;
            //System.out.println(o);
        }
        scanner.close();
        //按照他们的单价来冒泡排序（从高到低)
        bubble(price, mooncakes);
        


        //所卖的所有钱
        double all_money = 0.0;
        //4.循环开始出售月饼
        // 然后从高到低开始 卖掉   直到市场需求D为0
        for (int i = 0; i < mooncakes.length; i++) {
            if (D > 0) {
                if (D >= mooncakes[i]) {
                    D -= mooncakes[i];
                    //卖了  统计价格————单价乘数量
                    all_money += price[i];
                } else {
                    //此时我们的需求量少于排序中最多的月饼的所有量，按照我们的D来卖
                    all_money += D * (price[i]/mooncakes[i]);
                    D = 0;
                }
                if (D == 0) {
                    break;
                }
            }
        }
        //5.算出最大收益，打印
        System.out.printf("%.2f",all_money);
    }

    //这个冒泡排序是根据单价来确定的，所以传入两个数组，同时调正
    //他们的长度是一样的
    //第一个是售价，第二个是总量
    public static void bubble(double[] price, double[] num) {
        for (int i = 0; i < price.length - 1; i++) {
            for (int j = 0; j < price.length - 1 - i; j++) {
                if ((price[j] / num[j]) < (price[j + 1] / num[j + 1])) {
                    //两个数组与下一个换位置;
                    double temp1 = price[j];
                    price[j] = price[j + 1];
                    price[j + 1] = temp1;

                    double temp2 = num[j];
                    num[j] = num[j + 1];
                    num[j + 1] = temp2;
                }
            }
        }
    }
}

结果如下：

 而将Scanner替代为BufferedRead则能完美实现：

import java.util.Scanner;

public class Demo20 {

    public static void main(String[] args) {
        //1.接收第一行的种类数N与市场最大需求D
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        int D = scanner.nextInt();
        //2.接收第二行的N中月饼的含有量  —— 放入整形数组中   mooncakes[]
        double[] mooncakes = new double[N];
        for (int i = 0; i < N; i++) {
            mooncakes[i] = scanner.nextInt();
        }
        //3.接受第三行的对应月饼总售价   ——  放入另一个整型数组中 price[]
        double[] price = new double[N];
        for (int i = 0; i < N; i++) {
            price[i] = scanner.nextInt();
        }
        //按照他们的单价来冒泡排序（从高到低)
        bubble(price, mooncakes);
        


        //所卖的所有钱
        double all_money = 0.0;
        //4.循环开始出售月饼
        // 然后从高到低开始 卖掉   直到市场需求D为0
        for (int i = 0; i < mooncakes.length; i++) {
            if (D > 0) {
                if (D >= mooncakes[i]) {
                    D -= mooncakes[i];
                    //卖了  统计价格————单价乘数量
                    all_money += price[i];
                } else {
                    //此时我们的需求量少于排序中最多的月饼的所有量，按照我们的D来卖
                    all_money += D * (price[i]/mooncakes[i]);
                    D = 0;
                }
                if (D == 0) {
                    break;
                }
            }
        }
        //5.算出最大收益，打印
        System.out.printf("%.2f",all_money);
    }

    //这个冒泡排序是根据单价来确定的，所以传入两个数组，同时调正
    //他们的长度是一样的
    //第一个是售价，第二个是总量
    public static void bubble(double[] price, double[] num) {
        for (int i = 0; i < price.length - 1; i++) {
            for (int j = 0; j < price.length - 1 - i; j++) {
                if ((price[j] / num[j]) < (price[j + 1] / num[j + 1])) {
                    //两个数组与下一个换位置;
                    double temp1 = price[j];
                    price[j] = price[j + 1];
                    price[j + 1] = temp1;

                    double temp2 = num[j];
                    num[j] = num[j + 1];
                    num[j + 1] = temp2;
                }
            }
        }
    }
}