限定次数从数组两端获取最大总数（华为od机考题）

一、题目

一只贪吃的猴子，来到一个果园，发现许多串香蕉排成一行，每串香蕉上有若干根香蕉。
每串香蕉的根数由数组numbers给出。
猴子获取香蕉，每次都只能从行的开头或者末尾获取，
并且只能获取N次，求猴子最多能获取多少根香蕉。

二、思路与代码过程

1.思路

对数组获取元素，可以从头或者从尾，一共获取N次。

可以将数组头N个元素存储到队列Qf中，将尾N个元素存储到队列Qb中。

将队列Qf与Qb的头元素进行比较，较大的出列并动态存入graps数组中。

N次比较后将graps数组遍历，每个数相加赋值到maxBananas中。

由此就能得到最多的香蕉数量。

2.代码过程

①main函数

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入香蕉的串数：");
        int n = sc.nextInt();
        System.out.println("请输入每串香蕉上的根数：");
        int[] numbers = new int[n];
        for (int i = 0; i < n; i++) {
            numbers[i] = sc.nextInt();
        }
        System.out.println("香蕉数量数组为"+ Arrays.toString(numbers));
        System.out.println("请输入猴子能获取的次数N：");
        int N = sc.nextInt();
        System.out.printf("在%d次内猴子最多获得%d根香蕉\n",N,maxBanana(numbers,N));
    }

②maxBanana函数

主要负责对拿取方式和结果的判断，生成Qf和Qb队列，传入CompareRemove函数，处理传回来的graps数组，往主函数返回maxBananas。

private static int maxBanana(int[] numbers,int N) {
        //拿取为零次
        if (N == 0 ) {
            return 0;
        }
        //拿取次数大于等于堆数
        if ( N >= numbers.length){
            int count = 0;
            for (int i = 0 ; i < numbers.length ; i++){
                count += numbers[i];
            }
            System.out.println("香蕉堆数小于等于拿取次数，猴子可以全部拿完："+count);
            return count;
        }else {
            int maxBananas = 0;
            int n = numbers.length;
            Queue<Integer> Qf = new LinkedList<>();
            Queue<Integer> Qb = new LinkedList<>();
            for (int i = 0; i < N ; i++) {
                Qf.offer(numbers[i]);
                Qb.offer(numbers[n-i-1]);
            }
            System.out.println("前N个数为："+Arrays.toString(Qf.toArray()));
            System.out.println("后N个数为："+Arrays.toString(Qb.toArray()));
            ArrayList<Integer> BananaCount = CompareRemove(Qf,Qb,N);
            int bananasNum = 0;
            for (int i = 0; i < BananaCount.size(); i++) {
                int num = BananaCount.get(i);
                bananasNum += num;
            }
            maxBananas = bananasNum;
            return maxBananas;
        }
    }

③定义全局ArrayList graps确保传参不丢失

public static ArrayList<Integer> graps = new ArrayList<>();

④CompareRemove函数

接受maxBanana的传参Qf、Qb、N。对队列头元素的大小进行判断，并移除加入graps数组。

在遇到相等两端时，进入handleEqual函数。

private static ArrayList CompareRemove(Queue<Integer> qf, Queue<Integer> qb, int N) {
            for (int i = 0; i < N ; i++) {
            if (qf.isEmpty()||qb.isEmpty()) {
                System.out.println("队列一方为空");
                break;
            }
            Integer f = qf.peek();
            Integer b = qb.peek();
            if(f==null||b==null){
                System.out.println("两方队列均为空");
                break;
            }
            if (f>b){
                graps.add(qf.poll());
            }
            if(f<b){
                graps.add(qb.poll());
            }
            if (f==b){
                handleEqual(qf,qb,N,graps);
            }
        }
        return graps;
    }

⑤handleEqual函数

接受来自CompareRemove的传参:qf、qb、N、graps。

先将相等的两个元素都出列，在graps随便里添加一个（表示这个值我记录了），再将现在少了头元素的两个队列再次放入CompareRemove函数（次数N减一）。

private static void handleEqual(Queue<Integer> qf, Queue<Integer> qb, int N, ArrayList<Integer> graps) {
        Integer currentF = qf.poll();
        Integer currentB = qb.poll();
        graps.add(currentF);
        graps =CompareRemove(qf,qb,N-1);
    }

三、运行结果

1.带数据分析的完整代码

import java.util.*;
public class test15 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入香蕉的串数：");
        int n = sc.nextInt();
        System.out.println("请输入每串香蕉上的根数：");
        int[] numbers = new int[n];
        for (int i = 0; i < n; i++) {
            numbers[i] = sc.nextInt();
        }
        System.out.println("香蕉数量数组为"+ Arrays.toString(numbers));
        System.out.println("请输入猴子能获取的次数N：");
        int N = sc.nextInt();
        System.out.printf("在%d次内猴子最多获得%d根香蕉\n",N,maxBanana(numbers,N));
    }
//将数组numbers的前N个和后N个分别存入队列Qf和Qb，对Qf和Qb进行N次比较，并移除两者中较大一方的元素，进行N次

    private static int maxBanana(int[] numbers,int N) {
        //拿取为零次
        if (N == 0 ) {
            return 0;
        }
        //拿取次数大于等于堆数
        if ( N >= numbers.length){
            int count = 0;
            for (int i = 0 ; i < numbers.length ; i++){
                count += numbers[i];
            }
            System.out.println("香蕉堆数小于等于拿取次数，猴子可以全部拿完："+count);
            return count;
        }else {
            int maxBananas = 0;
            int n = numbers.length;
            Queue<Integer> Qf = new LinkedList<>();
            Queue<Integer> Qb = new LinkedList<>();
            for (int i = 0; i < N ; i++) {
                Qf.offer(numbers[i]);
                Qb.offer(numbers[n-i-1]);
            }
            System.out.println("前N个数为："+Arrays.toString(Qf.toArray()));
            System.out.println("后N个数为："+Arrays.toString(Qb.toArray()));
            ArrayList<Integer> BananaCount = CompareRemove(Qf,Qb,N);
            int bananasNum = 0;
            for (int i = 0; i < BananaCount.size(); i++) {
                int num = BananaCount.get(i);
                bananasNum += num;
            }
            maxBananas = bananasNum;
            return maxBananas;
        }
    }
    public static ArrayList<Integer> graps = new ArrayList<>();
    private static ArrayList CompareRemove(Queue<Integer> qf, Queue<Integer> qb, int N) {

        System.out.println("在compareremove第一步graps为："+String.valueOf(graps));
        for (int i = 0; i < N ; i++) {
            if (qf.isEmpty()||qb.isEmpty()) {
                System.out.println("队列一方为空");
                break;
            }
            Integer f = qf.peek();
            Integer b = qb.peek();
            if(f==null||b==null){
                System.out.println("两方均为空");
                break;
            }
            if (f>b){
                System.out.printf("qf的%d大于qb的%d",f,b);
                graps.add(qf.poll());
                System.out.println("大于后的graps为"+graps);
            }
            if(f<b){
                System.out.printf("qf的%d小于qb的%d",f,b);
                graps.add(qb.poll());
                System.out.println("小于后的graps为"+graps);
            }
            if (f==b){
                System.out.printf("qf的%d等于qb的%d需要进一步比较\n",f,b);
                handleEqual(qf,qb,N-1,graps);//??
                System.out.println("\n进入相等解决");
                System.out.println("相等解决后的graps为"+graps);
            }
        }
        return graps;
    }
    private static void handleEqual(Queue<Integer> qf, Queue<Integer> qb, int N, ArrayList<Integer> graps) {

        Integer currentF = qf.poll();
        Integer currentB = qb.poll();
        System.out.println("我是相等解决中的qf:"+qf+"，我是相等解决中的qb："+qb);
        graps.add(currentF);
        System.out.println("我是相等解决中的graps："+graps);
        graps =CompareRemove(qf,qb,N);
        System.out.println("我是相等解决中调用compareremove后的graps："+graps);
    }
}

2.运行结果