算法练习（八）区域搜索

一、腐烂的橘子

1、题目描述： 在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。

返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1

2、示例如下：

3、代码如下：

class Solution {
    public int orangesRotting(int[][] grid) {
        //边界，长和宽
        int M=grid.length;
        int N=grid[0].length;
        Queue<int[]> queue=new LinkedList<>();

        int count=0;    //新鲜橘子的数量
        for(int i=0;i<M;i++){
            for(int j=0;j<N;j++){
                if(grid[i][j]==1){  
                    count++;    //记录新鲜橘子
                }else if(grid[i][j]==2){
                    queue.add(new int[]{i,j});  //腐烂的橘子也记录下来
                }
            }
        }

        int round=0;    //时间、轮次
        while(count>0&&!queue.isEmpty()){   //当没有新鲜橘子且队列中的腐烂橘子遍历完时退出循环
            round++;
            int n=queue.size();     //记录当前层级的腐烂橘子数量，因为每层都会更新队列
            for(int i=0;i<n;i++){
                int[] orange=queue.poll();  //将当前层最先放入的橘子拿出
                int r=orange[0];
                int c=orange[1];
                if(r-1>=0&&grid[r-1][c]==1){    //更新四周橘子的状态
                    grid[r-1][c]=2;
                    count--;
                    queue.add(new int[]{r-1,c});
                }
                if(r+1<M&&grid[r+1][c]==1){
                    grid[r+1][c]=2;
                    count--;
                    queue.add(new int[]{r+1,c});
                }
                if(c-1>=0&&grid[r][c-1]==1){
                    grid[r][c-1]=2;
                    count--;
                    queue.add(new int[]{r,c-1});
                }
                if(c+1<N&&grid[r][c+1]==1){
                    grid[r][c+1]=2;
                    count--;
                    queue.add(new int[]{r,c+1});
                }
            }
        }

        if(count>0){    //若依然存在新鲜橘子，说明腐烂的橘子不可达
            return -1;
        }else{  //若不存在则输出轮次
            return round;
        }
    }
}

二、查找单入口空闲区域

1、题目描述： 给定一个 m x n 的矩阵，由若干字符 ‘X’ 和 'O’构成，'X’表示该处已被占据，'O’表示该处空闲，请找到最大的单入口空闲区域。

解释：
空闲区域是由连通的’O’组成的区域，位于边界的’O’可以构成入口，单入口空闲区域即有且只有一个位于边界的’O’作为入口的由连通的’O’组成的区域。
如果两个元素在水平或垂直方向相邻，则称它们是“连通”的。

2、示例如下：

3、代码如下：

import java.util.*;

public class danRuKou {

    public static int m;
    public static int n;
    public static String[][] strings;
    public static int[] rukou=new int[2];   //入口坐标
    public static int count=0;  //入口个数

    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        m=sc.nextInt();
        n=sc.nextInt();
        strings=new String[m][n];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                strings[i][j]=sc.next();
                //System.out.println(strings[i][j]);
            }
        }
        int max=0;
        List<int[]> quyu=new ArrayList<>();
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(strings[i][j].equals("O")){  //从左上开始遍历寻找第一个为O的坐标
                    strings[i][j]="X";
                    List<int[]> zuobiao=new ArrayList<>();  //保存当前空闲区域的所有坐标
                    zuobiao.add(new int[]{i,j});
                    qiuquyu(i,j,zuobiao);   //求当前空闲区域的所有坐标
                    if(count==1){   //如果入口只有一个则进行比较
                        if(max==zuobiao.size()){    //有大小相同的单入口空闲区域，则只需要大小，无需坐标
                            quyu.clear();
                        }else if(max<zuobiao.size()){   //若有更大的单入口空闲区域，则清除前面的那个，将当前的单入口空闲区域坐标放进去
                            quyu.clear();
                            quyu.add(new int[]{rukou[0],rukou[1],zuobiao.size()});
                            max=zuobiao.size();
                        }
                    }
                    count=0;
                    rukou=new int[2];
                }
            }
        }
        if(quyu.size()==1){ //如果单入口空闲区域只有1个，则直接输出
            int[] res=quyu.get(0);
            System.out.println(res[0]+" "+res[1]+" "+res[2]);
        }else if(max!=0){   //如果最大区域的面积不止为0，则输出最大区域
            System.out.println(max);
        }else { //如果没找到，则输出NULL
            System.out.println("NULL");
        }
    }

    //得到单入口区域
    public static void qiuquyu(int x,int y,List<int[]> list){
        if(x==0||x==m-1||y==0||y==n-1){
            count++;
            rukou[0]=x;
            rukou[1]=y;
        }
        if (x<m-1){
            if(strings[x+1][y].equals("O")){    //因为是按顺序来，所以只需要向右或者向下遍历即可
                strings[x+1][y]="X";
                list.add(new int[]{x+1,y});
                qiuquyu(x+1,y,list);
            }
        }
        if (y<n-1){
            if(strings[x][y+1].equals("O")){
                strings[x][y+1]="X";
                list.add(new int[]{x,y+1});
                qiuquyu(x,y+1,list);
            }
        }
    }
}

三、开心消消乐

1、题目描述： 给定一个N行M列的二维矩阵，矩阵中每个位置的数字取值为0或1。矩阵示例如：
1 1 0 0
0 0 0 1
0 0 1 1
1 1 1 1
现需要将矩阵中所有的1进行反转为0，规则如下：
1）当点击一个1时，该1变被反转为0，同时相邻的上、下、左、右，以及左上、左下、右上、右下8个方向的1（如果存在1）均会自动反转为0；
2）进一步地，一个位置上的1被反转为0时，与其相邻的8个方向的1（如果存在1）均会自动反转为0；
按照上述规则示例中的矩阵只最少需要点击2次后，所有值均为0。请问，给定一个矩阵，最少需要点击几次后，所有数字均为0？

2、示例如下：

3、代码如下：

import java.util.*;

public class kaiXingXiaoXiaoLe {
    public static int[][] juzhen;
    public static int N;
    public static int M;

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        N=sc.nextInt();
        M=sc.nextInt();
        juzhen=new int[N][M];
        for (int i=0;i<N;i++){  //保存二维数组
            for (int j=0;j<M;j++){
                juzhen[i][j]=sc.nextInt();
            }
        }
        int res=0;
        for (int i=0;i<N;i++){  //开始清除
            for (int j=0;j<M;j++){
                if (juzhen[i][j]==1){
                    clearHappy(i,j);
                    res++;
                }
            }
        }
        System.out.println(res);
    }

    //8个方向都清一遍
    public static void clearHappy(int x,int y){
        if (x>0){
            if(juzhen[x-1][y]==1){  //正上
                juzhen[x-1][y]=0;
                clearHappy(x-1,y);
            }
            if(y>0){
                if(juzhen[x-1][y-1]==1){    //左上
                    juzhen[x-1][y-1]=0;
                    clearHappy(x-1,y-1);
                }
            }
            if(y<M-1){
                if(juzhen[x-1][y+1]==1){    //右上
                    juzhen[x-1][y+1]=0;
                    clearHappy(x-1,y+1);
                }
            }
        }
        if(x<N-1){
            if(juzhen[x+1][y]==1){      //正下
                juzhen[x+1][y]=0;
                clearHappy(x+1,y);
            }
            if(y>0){
                if(juzhen[x+1][y-1]==1){    //左下
                    juzhen[x+1][y-1]=0;
                    clearHappy(x+1,y-1);
                }
            }
            if(y<M-1){
                if(juzhen[x+1][y+1]==1){    //右下
                    juzhen[x+1][y+1]=0;
                    clearHappy(x+1,y+1);
                }
            }
        }
        if(y>0){
            if(juzhen[x][y-1]==1){  //正左
                juzhen[x][y-1]=0;
                clearHappy(x,y-1);
            }
        }
        if(y<M-1){
            if(juzhen[x][y+1]==1){  //正右
                juzhen[x][y+1]=0;
                clearHappy(x,y+1);
            }
        }
    }
}