华为机试真题 Java 实现叠积木

Posted 2022-12-11 MISAYAONE

目录

题目

思路

考点

Code

---

题目

有一堆长方体积木，它们的长度和宽度都相同，但长度不一。

小橙想把这堆积木叠成一面墙，墙的每层可以放一个积木，也可以将两个积木拼接起来，要求每层的长度相同。

若必须用完这些积木，叠成的墙最多为多少层？

如下是叠成的一面墙的图示，积木仅按宽和高所在的面进行拼接。

 

输入描述：

输入为一行，为各个积木的长度，数字为正整数，并由空格分隔。积木的数量和长度都不超过5000。

输出描述：

输出一个数字，为墙的最大层数，如果无法按要求叠成每层长度一致的墙，则输出-1。

输入

给定积木的长度，以空格分隔，例如:3 6 6 3。

输出

如果可以搭建，返回最大层数，如果不可以返回-1。

示例1   输入输出示例仅供调试，后台判题数据一般不包含示例

输入

3 6 3 3 3

输出

3

解释：以 6 为底的墙，第一层为 6 ，第二层为 3 + 3，第三层 3 + 3。

示例2   输入输出示例仅供调试，后台判题数据一般不包含示例

输入

9 9 9 5 3 2 2 2 2 2

输出

5

解释：

5+2+2=9

3+2+2+2=9

9,9,9

共五层

思路

1：其实还是最暴力的遍历方法，每一层的长度和一样，那么我们可以想到，如果所有积木的长度为sum，那么可能堆到的层数范围就是 [2, sum/2]。

2：首先我们可以检测出一个特殊情况 “ 如果所有数字的和除不尽层数，自然肯定不满足条件”。

3：其次，我们当作层数为i，那么sum / i 就是每一层的长度，我们递归的将每一个积木组成这个长度，如果组不成，则失败，如果组成了，则继续向下遍历。（注意数组要先排序）

考点

1：递归法

Code

import java.util.Scanner;
import java.util.*;

public class Main  
    public static void main(String[] args)  
        //处理输入
        Scanner in = new Scanner(System.in);
        String[] s = in.nextLine().split(" ");
        int[] nums = new int[s.length];
        for (int i = 0; i < nums.length; i++) 
            nums[i] = Integer.parseInt(s[i]);
        

        //求和并排序
        int sum = 0;
        for (int num : nums) 
            sum += num;
        
        Arrays.sort(nums);

        // 墙的最大层数
        int max_layer = -1;
         // i表示可能堆的层数
        for (int i = 2; i <= sum / 2; i++) 
            // 如果所有数字的和除不尽层数，自然肯定不满足条件
            if (sum % i != 0) continue;
            // 每一层的长度为layer_length
            int layer_length = sum / i;
            if(nums[nums.length - 1] > layer_length)
                continue;
            
            int[] arr = new int[i];
            Arrays.fill(arr, layer_length);
            // 递归找层数
            if (dfs (nums, nums.length - 1, 0, arr, i, layer_length)) 
                max_layer = Math.max(max_layer, i);
            
        
        System.out.println(max_layer);
    
    public static boolean dfs(int[] nums, int cur, int used_cnt, int[] arr, int k, int layer_length)
        if(cur < 0)
            return true;
        
        if (used_cnt < k) 
            arr[used_cnt] = nums[cur];
            if (dfs(nums, cur - 1, used_cnt + 1, arr, k, layer_length)) 
                return true;
            
            arr[used_cnt] = 0;
        
        
        for(int i = 0; i < used_cnt; i++)
            
            if (i > 0 && arr[i] == arr[i - 1]) continue;
            if (arr[i] + nums[cur] <= layer_length) 
                arr[i] += nums[cur];
                if (dfs(nums, cur - 1, used_cnt, arr, k, layer_length)) return true;
                arr[i] -= nums[cur];
            
        
        return false;