2019.8.15 360笔试两道算法题（Java）

1.求表面积

题目描述：

将长N*M厘米的矩形区域划分成N行M列（每行每列的宽度均为1厘米），在第i行第j列的位置上叠放Ai,j个边长为1厘米的正方体（1≤Ai,j≤100），所有正方体就组成了一个立体图形，每个正方体六个面中的一部分会被其它正方体遮挡，未被遮挡的部分的总面积即为该立体图形的表面积，那么该立体图形的表面积是多少平方厘米？

样例解释：

第一行包含两个整数N和M，1≤N，M≤1000。
接下来N行，每行包含M个整数，第i行的第j个整数表示Ai,j。
输出表面积的大小。

例如：

输入：
	2 2
	2 1
	1 1
输出：
	20

思路：

先求出所有正方体未被遮挡时的表面积，然后再减去遮挡部分的。
我将遮挡部分分为3个部分：1.在第一层上被遮挡的面积
2.在某列上堆积的正方体被遮挡的面积
3.在第一层之上被遮挡的面积

参考代码：

函数surfaceArea是leetcode上892题的代码，和该题很类似。

package com.lx.eurekaclient.action;

import java.util.Scanner;
public class Main_360 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNextInt()){
            int init = 0,red = 0, res = 0;
            int N = scanner.nextInt();
            int M = scanner.nextInt();
            int[][] m = new int[N][M];
            for (int i = 0; i < m.length; i++) {
                for (int j = 0; j < m[0].length; j++) {
                    m[i][j] = scanner.nextInt();
                    init += m[i][j];
                }
            }
            init = init * 6;//未遮挡的面积

            for (int i = 0; i < m.length; i++) {
                for (int j = 0; j < m[0].length; j++) {
                    //前两个if是求水平的遮挡
                   if(i + 1 < m.length && m[i][j] > 0 && m[i + 1][j] >= 1)
                       red += 2;
                   if(j + 1 < m[0].length && m[i][j] > 0 && m[i][j + 1] >= 1)
                       red += 2;
                   //求垂直遮挡
                   if(m[i][j] > 1){
                       red += (m[i][j] - 1) * 2;//在一列上的垂直遮挡
                       //求垂直方向上的水平遮挡
                       if(i + 1 < m.length && m[i + 1][j] > 1)
                           red += (Math.min(m[i][j],m[i + 1][j]) - 1) * 2;
                       if(j + 1 < m[0].length && m[i][j + 1] > 1)
                           red += (Math.min(m[i][j],m[i][j + 1]) - 1) * 2;
                   }
                }
            }
            res = init - red;
            System.out.println(res);


        }
    }

    public int surfaceArea(int[][] grid) {//leetcode  892题
        int res = 0,init = 0,red = 0;
        if(grid == null || grid.length == 0)
            return 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                init += grid[i][j];
                if(i+1 < grid.length && grid[i][j] > 0 && grid[i+1][j] >= 1)
                    red += 2;
                if(j+1 < grid[0].length && grid[i][j] > 0 && grid[i][j+1] >= 1)
                    red += 2;
                if(grid[i][j] > 1){
                    red += (grid[i][j] - 1) * 2;
                    if(i+1 < grid.length && grid[i + 1][j] > 1)
                        red += (Math.min(grid[i][j],grid[i + 1][j]) - 1) * 2;
                    if(j+1 < grid[0].length && grid[i][j + 1] > 1)
                        red += (Math.min(grid[i][j],grid[i][j + 1]) - 1) * 2;
                }
            }
        }
        res = 6 * init - red;
        return res;

    }


}

2.两个数字，m进制，n位数，可以重新排序数字的顺序，两个数对应相加并对m取模而不进位，求最大和

题目描述：

在一个古老的国度，这个国家的人并不懂得进位，但是对取模情有独钟，因此诞生了一个经典的问题，给出两个在m进制下含有n位的数字，你可以分别将这两个数各位上的数字重新排列，然后将两个数按位对应相加并分别对m取模， 这样显然可以得到一…1个新的m进制下的n位数(可能存在前导0)，但是这个结果是不唯一的，问题来了，按照这样的操作，能够得到的最大的m进制下的数字是多少呢。

样例解释：

输入第一行包含两个正整数n,m分别表示数字含有n位，和在m进制下。
输入第二行和第三行分别包含n个整数，中间用空格隔开，每个整数都在0到m-1之间。每行第i个数表示的是当前数第i位上的数字。
输出包含n个数字，中间用空格隔开，表示得到的最大的数字，从高位到低位输出，如6在2进制下输出3位的结果是1 1 0。

例如：

输入：
	 5 5
	 4 4 1 1 1
	 4 3 0 1 2
输出：
	 4 4 3 3 2

• 4 4 1 1 1 →1 4 1 4 1
• 4 3 0 1 2 →3 0 2 4 1（重排序列不唯一，数位相加后的数字为 4 4 3 8 2，对5取模即可 ）

思路：

贪心法，尽可能多构造m进制下最大的数，假设m为5，则尽可能的多构造4，其次是3、2、1，直到集合listA为空 结束循环。

参考代码：

package com.lx.eurekaclient.action;

import java.util.*;
public class Main_360_2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();
            int m = scanner.nextInt();
            List<Integer> listA = new ArrayList<>(n);
            List<Integer> listB = new ArrayList<>(n);
            List<Integer> res = new ArrayList<>(n);
            for (int i = 0; i < 2 * n; i++) {
                if (i < n)
                    listA.add(scanner.nextInt());
                else
                    listB.add(scanner.nextInt());
            }
            //贪心法，假设m为5，则尽可能的多构造4，其次是3、2、1，直到集合listA为空   结束循环
            int redu = 1;//构造因子，当redu为1时，表示构造4
            while (!listA.isEmpty()) {
                Iterator iterator = listA.iterator();
                while (iterator.hasNext()){
                    int integer = (int)iterator.next();
                    int dif = m - integer - redu;//两数相加小于m的情况
                    int dif2 = m -integer + m - redu;//两数相加大于m的情况
                    if (listB.contains(Integer.valueOf(dif))) {
                        iterator.remove();
                        listB.remove(Integer.valueOf(dif));
                        res.add(m - redu);
                    }else if (listB.contains(Integer.valueOf(dif2))) {
                        iterator.remove();
                        listB.remove(Integer.valueOf(dif2));
                        res.add(m - redu);
                    }
                }
                redu++;//上个最大的数构造完毕，继续构造小一点的数
            }
            System.out.println(res);
        }
    }


}