(求正数数组的最小不可组成和，养兔子）笔试强训

• 博主简介：想进大厂的打工人
• 博主主页：@xyk:
• 所属专栏: JavaEE初阶

---

目录

文章目录

一、选择题1

二、[编程题]养兔子

三、[编程题]求正数数组的最小不可组成和

---

一、选择题1

reflection是如何工作的__牛客网 (nowcoder.com)

考虑下面这个简单的例子，让我们看看reflection是如何工作的。

import java.lang.reflect.*;
public class DumpMethods{
	public static void main(String[] args) {
		try {
			Class c=Class.forName(args[0]);
			Method m[]=c.getDeclaredMethods();
			for (int i = 0; i < m.length; i++) {
				System.out.println(m[i].toString());
			}
		} catch (Throwable e) {
			System.err.println(e);
		}
	}
}

其中"c.getDeclaredMethods"的作用是:

public Method[] getDeclaredMethods()返回类或接口声明的所有方法，包括public, protected, default (package) 访问和private方法的Method对象，但不包括继承的方法。当然也包括它所实现接口的方法。

public Method[] getMethods()返回类的所有public方法，包括其继承类的公用方法，当然也包括它所实现接口的方法。

所以答案选D~~~

二、[编程题]养兔子

养兔子__牛客网 (nowcoder.com)

一只成熟的兔子每天能产下一胎兔子。每只小兔子的成熟期是一天。 某人领养了一只小兔子，请问第N天以后，他将会得到多少只兔子。

对于这样的题目主要是抓住递推式的关系。

我对于F(n)=F(n-1)+1*F(n-2)的公式理解是这样的。F(n-1)代表昨天的兔子总量。

F(n-2)代表前天的兔子总量，刚好只有前天的兔子具有生产能力。

//就是斐波那契数列
import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n = sc.nextInt();
            
            long[] arr = new long[91];
            arr[1] = 1;
            arr[2] = 2;
            for(int i = 3;i < arr.length;i++){
                arr[i] = arr[i-1] + arr[i-2]; 
            }
            System.out.println(arr[n]);
        }
    }
}

所以如果题目改成一只成熟的兔子能够生产2只，那么通项公式为F(n)=F(n-1)+2*F(n-2)

方法二：

 public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n = sc.nextInt();
            long f0 = 1;
            long f1 = 1;
            long f2 = 1;
            for(int i = 2;i <= n;i++){
                f2 = f1 +f0;
                f0 = f1;
                f1 = f2;
            }
            System.out.println(f2);
        }
    }

三、[编程题]求正数数组的最小不可组成和

链接：求正数数组的最小不可组成和_百度笔试题_牛客网
来源：牛客网

给定一个全是正数的数组arr，定义一下arr的最小不可组成和的概念：

1，arr的所有非空子集中，把每个子集内的所有元素加起来会出现很多的值，其中最小的记为min，最大的记为max；

2，在区间[min,max]上，如果有一些正数不可以被arr某一个子集相加得到，那么这些正数中最小的那个，就是arr的最小不可组成和；

3，在区间[min,max]上，如果所有的数都可以被arr的某一个子集相加得到，那么max+1是arr的最小不可组成和；

举例： arr = {3,2,5} arr的min为2，max为10，在区间[2,10]上，4是不能被任何一个子集相加得到的值中最小的，所以4是arr的最小不可组成和； arr = {3,2,4} arr的min为2，max为9，在区间[2,9]上，8是不能被任何一个子集相加得到的值中最小的，所以8是arr的最小不可组成和； arr = {3,1,2} arr的min为1，max为6，在区间[2,6]上，任何数都可以被某一个子集相加得到，所以7是arr的最小不可组成和；

请写函数返回arr的最小不可组成和。

---

看了题之后， 是不是没有思路？？

我看题之后，首先想到了把所有元素组合的方式加起来，填入一个集合中，然后一个一个进行比对，如果从小到大没有的数，就返回~~两种情况！

1.[min,max] 有正数不能被子集相加得到! 返回该数

2.[min,max] 所以正数都能被子集相加得到 返回 max+1

回溯法：

import java.util.*;
public class Solution {
	/**
	 *	正数数组中的最小不可组成和
	 *	输入：正数数组arr
	 *	返回：正数数组中的最小不可组成和
	 */
    public void getNumber(int[] arr,ArrayList<Integer> result,int pos,int sum){
        if(pos==arr.length){
            return;
        }
        for(int i = pos;i<arr.length;i++){
            sum += arr[i];
            result.add(sum);
            getNumber(arr,result,i+1,sum);
            sum -= arr[i];
        }
    }
	public int getFirstUnFormedNum(int[] arr) {
         //2种情况: 1.[min,max] 有正数不能被子集相加得到! 返回该 数
         //        2.[min,max] 所以正数都能被子集相加得到 返回 max+1
        Arrays.sort(arr);
        int min = arr[0];
        int max = arr[0];
        ArrayList<Integer> result = new ArrayList<>();
        getNumber(arr,result,0,0);
        for(int i = 1;i<arr.length;i++){
            max += arr[i];
        }
        for(int i = min+1;i<max;i++){
            if(!result.contains(i)){
                return i;
            }
        }
        return max+1;
	}
}

方法二：想象为背包问题

1、我们先来看一个背包问题：

思路借鉴牛客大佬

此时，模拟背包问题代码：

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();//输入商品个数
        int Max_room = scanner.nextInt();//输入袋子容量
        int[] weight = new int[n];
        int[] price = new int[n];
        int i = 0;
        while (i < n){
            weight[i++] = scanner.nextInt();
        }
        i = 0;

        while (i < n){
            price[i++] = scanner.nextInt();
        }

        int[][] dp = new int[n + 1][Max_room + 1];

        for (i = 1; i <= n; i++) {
            for (int j = 1; j <= Max_room; j++) {
                if (weight[i - 1] > j) {//袋子的容量不够
                    dp[i][j] = dp[i - 1][j];
                } else {//袋子容量足够
                    dp[i][j] = Math.max(dp[i - 1][j], price[i - 1] + dp[i - 1][j - weight[i - 1]]);
                }
            }
        }
        System.out.println(dp[n][Max_room]);
    }

这道题，可以看作是背包问题的变形 背包容量的范围在【min，max】,arr数组相当于每个物品的重量

如果背包容量和所承载的物品重量不相等，就是所求

可以转换的原因是：背包容量[min,max]是数组的子集之和的范围

 

    public static int getFirstUnFormedNum(int[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }
        if (arr.length == 1) {//只有一个元素 ，在区间[min,max]上，如果所有的数都可以被arr的某一个子集相加得到，那么max+1是arr的最小不可组成和；
            return arr[0] + 1;
        }
        int min = arr[0];
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            max += arr[i];
            min = Math.min(arr[i], min);
        }
        int[] dp = new int[max + 1];


        for (int i = 0; i <arr.length ; i++) {
            for (int j = max; j >= arr[i]; j--) {
                //dp数组从后向前赋值
                dp[j] = Math.max(dp[j], dp[j - arr[i]] + arr[i]);
            }
        }

        for (int i = min; i < max; i++) {
            if (dp[i] != i)
                return i;
        }
        return max + 1;
    }