华为8.19笔试题目分析

1、题目一

题目描述：

已知有一堆人排成M行N列，（M，N均大于等于10小于等于1000），现在从这群人中挑选一些人出来。在这个M行N列的队伍中，每个人对应一个坐标，从最左上角的（0,0）到右下角的（M-1，N-1）。这些人还会进行一次报数，报数顺序是按照类似蜗牛壳形状的顺时针方向由外圈像内圈报数，当报数的个位数为7且十位数为奇数的人出列，按报数顺序输出这些人的坐标。

例如：如下图所示一个5行5列的队伍，按顺时针顺序从外到里报数，其中17满足条件，因此需要输出17的坐标(1,1)。

输入行数M和列数N：

10 10

输出为满足条件的坐标：

[[7,9],[1,1],[8,2],[7,5],[4,4]]

要注意输出时候有个坑，前面几组输出坐标后还会输出一个逗号分隔，最后一组坐标之后不输出逗号，因此需要把最后一个满足条件的坐标找出来，输出得时候不输出逗号。

思路：

public class First {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            int m=sc.nextInt();
            int n=sc.nextInt();
            if(m<10||m>1000||n<10||n>1000){
                System.out.println("[]");
                continue;
            }
            int[][] arr=new int[m][n];
            getNum(arr);
        }
    }
    public static void getNum(int[][] arr){
        List<int[]> list=new LinkedList<>();
        int left=0,right=arr[0].length-1,top=0,buttom=arr.length-1,num=0;
        while(true){
            // left to right
            for(int i=left;i<=right;i++){
                num++;
                if(judge(num)){
                    //变化的是列，行为top
                    list.add(new int[]{top,i});
                }
            }
            //res[x++] 等价于先给 res[x] 赋值，再给 x 自增 1；
            //++t > b 等价于先给 t 自增 1 ，再判断 t > b 逻辑表达式。
            if(++top>buttom)break;
            // top to bottom
            for(int i=top;i<=buttom;i++){
                num++;
                if(judge(num)){
                    //变化的是行，列为right
                    list.add(new int[]{i,right});
                }
            }
            if(--right<left)break;
            // right to left
            for(int i=right;i>=left;i--){
                num++;
                if(judge(num)){
                    //变化的是列，行为buttom
                    list.add(new int[]{buttom,i});
                }
            }
            if(--buttom<top)break;
            // bottom to top
            for(int i=buttom;i>=top;i--){
                num++;
                if(judge(num)){
                    //变化的是行，列为left
                    list.add(new int[]{i,left});
                }
            }
            if(++left>right)break;
        }
        for(int i=0;i<list.size();i++){
            System.out.println(Arrays.toString(list.get(i)));
        }
    }
    public static boolean judge(int k){
        //个位是7，十位为奇数
        return k%10==7&&(k/10)%2==1;
    }
}

2、题目二

给定二叉树每个节点的深度，计算多少种满足条件的二叉树。根节点深度为0。

输入描述：
第一行为一个整数N，表示二叉树节点的数量,在1到1000之间。
第二行为N个整数，d1,d2,……dN表示每个节点的深度。
输出描述：
输出为满足条件的二叉树数量。由于结果可能非常大，因此输出为实际结果除以（10^9+7）之后的余数。

例子，
输入：

4
1 0 2 2

输出：

2

解题思路：

上述例子中的输入表示深度为1的节点有一个，深度为0的节点有一个，深度为2的节点有两个。对应的两种二叉树的形状如下图所示：由答案为2可以知道该题目不区分元素的不同，只根据二叉树的形状进行分类。如果考虑元素分布的话，下图中D2-1和D2-2交换位置则又多了一倍的种类，因此此题目只考虑多少种形状的二叉树即可，即只考虑组合不考虑排列。

首先要根据输入把二叉树每层多少个节点数目统计好。例如D0,D1,D2……DN分别表示第0层，1层，……N层的节点数目。对于第i层，该层有Di个节点，则第i+1层有2Di个位置，因此需要从2Di个位置中选D(i+1)个位置进行放置，则放置方法有：

然后把所有层的放置方法数全部乘起来就得到最后总的不同形状二叉树数量。

如上面的例子：第0 1 2层的节点数为1 1 2。因此对于第一层，有2个位置选一个有2种选取方法，对于第2层，从2个位置选两个有1种选择方法，因此总方法有2*1=2种方法，也就是两种不同形状的二叉树。

public class Second {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            int num=sc.nextInt();
            int max=0;
            HashMap<Integer,Integer> map=new HashMap<>();
            for(int i=0;i<num;i++){
                int tem=sc.nextInt();
                if(tem>max){
                    max=tem;
                }
                if(map.containsKey(tem)){
                    map.put(tem,map.get(tem)+1);
                }else{
                    map.put(tem,1);
                }
            }
            if(map.get(0)<1){
                continue;
            }
            long sum=1;
            int tem=1;
            for(int i=0;i<=max;i++){
                if(map.get(i)==0){
                    System.out.println(sum%(1000000000+7));
                    break;
                }
                if(i==0){
                    tem=2*map.get(0);
                }else{
                    sum=sum*getSum(tem,map.get(i));
                    tem=2*map.get(i);
                }
            }
            System.out.println(sum%(1000000000+7));
        }
    }
    public static long getSum(int m,int n){
        long tem=1;
        long tem2=1;
        for(int i=0;i<n;i++){
            tem=tem*(m-i);
            tem2=tem2*(i+1);
        }
        return tem/tem2;
    }
}

3、题目三

题目：
俄罗斯方块，输入有两个字符串，第一个frame表示当前底座状态，第二个brick表示下落方块的状态，下落的方块只能左右移动不会旋转。方块落下后如果一行全部充满则会消失，最后求最少还剩多少行。输入的底座和方块都不超过9列，即最大只有9列。

输入为：

2122
121

底座和方块状态如下图所示：其中2122表示当前底座状态，都是底对齐的，而121表示下落方块的状态，都是顶对齐的，即2的位置的突出是往下凸而不是往上凸。下图运行结果为1，下图中方块左右移动有两种下落方式，一种如下图所示，下落后会消去两行最后剩余1行。另外一种下落方式是向又移动一格然后再下落，最后消去一行剩余3行，因此最少的结果是剩余1行，输出为1。

输出为：

1

解题思路：
给定两个字符串 frame 是底下基座，brick 是落下的方块，判断brick落下后，消除完无空行的行后，剩下的最小行数。
首先计算两个字符串的长度 lenF 和 lenB，然后把brick字符串与frame字符串通过一个for循环进行错位相加（错位的位数从0到lenF-lenB），分别计算每种情况下的剩余行数的最大值，然后求全部最大值中的最小值。

代码为：

package huawei819;

import java.util.Scanner;

/**
 * 首先计算两个字符串的长度 lenF 和 lenB，然后把brick字符串与frame字符串通过一个for循环进行错位相加
 * 分别计算每种情况下的剩余行数的最大值，然后求全部最大值中的最小值
 */
public class Three {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            //底座
            String frame=sc.nextLine().trim();
            //下落方块
            String brick=sc.nextLine();
            minRow(frame,brick);
        }
    }
    public static void minRow(String frame,String brick){
        //底座长度
        int frameLen=frame.length();
        //下落方块的长度
        int brickLen=brick.length();
        //左右移动方块共有num种掉落方法
        int num=frameLen-brickLen+1;
        int res = 9999999;
        for(int i=0;i<num;i++){
            String tem=brick;
            int[] arr=new int[frameLen];
            //对下落的方块进行补0，方便相加，主要是对brick后面补0
            for(int j=0;j<num-i-1;j++){
                tem+="0";
            }
            //对应位置的数相加，保存数组中
            for(int j=0;j<frameLen;j++){
                if(j<i){
                    arr[j]+=(frame.charAt(j)-'0');
                }else{
                    arr[j]+=(frame.charAt(j)-'0');
                    arr[j]+=(tem.charAt(j-i)-'0');
                }
            }
            int maxtemp = -9999999, mintemp = 9999999, maxH = -9999999;
            //求每次错位相加消除后，剩下的最高的一列的高度
            //在该循环中maxtemp代表最高列的值，mintemp代表最低列的值
            //maxH代表最高列-最低列的值，也就是消除公共行之后，列的最高值
            for (int j = 0; j < arr.length; j++){
                maxtemp = Math.max(maxtemp, arr[j]);
                mintemp = Math.min(mintemp, arr[j]);
                maxH = Math.max(maxH, maxtemp - mintemp);
            }
            //几次下落方式中，消除公共行之后列的最小值即为所求
            res=Math.min(res,maxH);
        }
        System.out.println(res);
    }
}