华为OD机考真题-- | 200分-宜居星球改造计划-带答案

题目描述:

宜居星球改造计划
2XXX年，人类通过对火星的大气进行宜居改造分析，使得火星已在理论上具备人类宜居的条件；

由于技术原因，无法一次性将火星大气全部改造，只能通过局部处理形式；

假设将火星待改造的区域为row *
column的网格，每个网格有3个值，宜居区、可改造区、死亡区，使用YES、NO、NA代替，YES表示该网格已经完成大气改造，NO表示该网格未进行改造，后期可进行改造，NA表示死亡区，不作为判断是否改造完的宜居，无法穿过；

初始化下，该区域可能存在多个宜居区，并目每个宜居区能同时在每个大阳日单位向上下左右四个方向的相邻格子进行扩散，自动将4个方向相邻的真空区改造成宜居区；

请计算这个待改造区域的网格中，可改造区是否能全部成宜居区，如果可以，则返回改造的大阳日天教，不可以则返回-1

输入描述

输入row * column个网格数据，每个网格值枚举值如下: YES，NO，NA；

样例:

YES YES NO
NO NO NO
NA NO YES

输出描述

可改造区是否能全部变成宜居区，如果可以，则返回改造的太阳日天数，不可以则返回-1。

备注
grid[i][j]只有3种情况，YES、NO、NA

row == grid.length
column == grid[i].length
1 ≤ row, column ≤ 8

用例一
输入

YES YES NO
NO NO NO
YES NO NO

输出

2
说明

经过 2 个太阳日，完成宜居改造。

用例二
输入

YES NO NO NO
NO NO NO NO
NO NO NO NO
NO NO NO NO

输出

6
说明

经过 6 个太阳日，可完成改造

用例三
输入

NO NA
输出

-1
说明

无改造初始条件，无法进行改造

用例四
输入

YES NO NO YES
NO NO YES NO
NO YES NA NA
YES NO NA NO

输出

-1
说明

-1 ，右下角的区域，被周边三个死亡区挡住，无法实现改造

public class PlantaryModification {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[][] value = new String[8][8];
        int i = 0;
        Boolean NA = false;
        int countDay = 0;
        while (sc.hasNextLine()){
            String in = sc.nextLine();
            if (in.isEmpty()){
                break;
            }
            String[] valueLine = in.split(" ");
            for (int j = 0; j<valueLine.length;j++){
                //检查是否有死亡区
                if (valueLine[j].equals("NA")){
                    NA = true;
                }
                value[i][j] = valueLine[j];
            }
            i++;
        }
        //有死亡区直接返回-1
        if (NA){
            countDay = -1;
            System.out.println(countDay);
            return;
        }
        //取出null无效占用空间
       /* String [][] filterValue = Arrays.stream(value)
                .flatMap(Arrays::stream)
                .filter(Objects::nonNull)
                .toArray(String[][]::new);*/
        Set<YN> yns = new HashSet<>();
         countDay = countDay(value,countDay,0,0,yns);
        System.out.println(countDay);
    }

    /**
     * @param value
     * @param countDay
     * @return
     */
    public static int countDay(String[][]value,int countDay,int m,int n,Set<YN> yns){
        //统计所有的YES值，后续操作,相当于初始化，只执行一次
        if (yns.isEmpty()) {
            for (int i = m; i < value.length; i++) {
                for (int j = n; j < value[i].length; j++) {
                    if (StringUtils.isEmpty(value[i][j])) {
                       break;
                    }else if (value[i][j].equals("YES")) {
                        YN yn = new YN(i, j);
                        yns.add(yn);
                    }
                }
            }
        }
        //每次刷新一天后看是否还存在NO值
        Boolean end = true;
        while (end) {
            for (int i = m; i < value.length; i++) {
                for (int j = n; j < value[i].length; j++) {
                    if (!StringUtils.isEmpty(value[i][j]) && value[i][j].equals("NO")) {
                        countDay++;
                        noToYes(value, yns, countDay, m, n);
                    }
                }
            }
            end = false;
        }
        return countDay;
    }
    public static void noToYes(String[][]value,Set<YN> yns,int countDay,int m,int n){
        Set<YN> ynsA = new HashSet<>();
        for (YN yn : yns){
            //上下左右
            UDLF(value, ynsA, yn);
        }
        //合并(每一天存量更新)
        for (YN yn : ynsA){
            yns.add(yn);
        }
    }

    private static void UDLF(String[][] value, Set<YN> ynsA, YN yn) {
        YN upYn = new YN(yn.m,yn.n-1);
        move(value,ynsA,upYn);
        YN domw = new YN(yn.m,yn.n+1);
        move(value,ynsA,domw);
        YN left = new YN(yn.m-1,yn.n);
        move(value,ynsA,left);
        YN right = new YN(yn.m+1,yn.n);
        move(value,ynsA,right);
    }

    public static void move(String[][] value, Set<YN> ynsA,YN yn){
        if (yn.m < value.length && yn.m >= 0 && yn.n < value[yn.m].length && yn.n >=0){
            if (!StringUtils.isEmpty(value[yn.m][yn.n]) && value[yn.m][yn.n].equals("NO")){
                value[yn.m][yn.n] = "YES";
                YN ynA = new YN(yn.m, yn.n);
                ynsA.add(ynA);
            }
        }
    }

    static class YN{
        int m;
        int n;

        public YN(int m, int n) {
            this.m = m;
            this.n = n;
        }
    }
}