岛屿中的曼哈顿问题

最新推荐文章于 2024-09-27 00:32:45 发布

fancyZiZi~

最新推荐文章于 2024-09-27 00:32:45 发布

阅读量135

点赞数

文章标签：深度优先算法 java

本文链接：https://blog.csdn.net/jireen/article/details/126187625

版权

这篇博客介绍了如何使用深度优先搜索（DFS）算法来解决两种经典问题：计算二维网格中的岛屿数量以及找出岛屿之间的最大曼哈顿距离。首先，通过DFS遍历网格，当遇到值为1的节点时，开始搜索并标记为0，以此来计数岛屿。然后，存储DFS过程中访问的坐标，并计算曼哈顿距离，即所有坐标对之间的最大水平和垂直距离之差。博客提供了详细的代码实现，包括核心的DFS函数和曼哈顿距离计算方法。

摘要由CSDN通过智能技术生成

在这里插入图片描述

主要是：

如何求岛屿数量
如何求岛屿的最大曼哈顿

第一个问题
岛屿数量用dfs，如果graph[i][j]==1，那么就进行dfs搜索
dfs搜索函数中，要在岛屿的四个方向上进行搜索
第二个问题
最大曼哈顿，可以参考力扣1131题，一次遍历
其他
为了求解曼哈顿方便，可以存储一下dfs中的坐标，用两个list存储，方便后续转换为数组
代码如下

 public static void main(String[] args) {
        int[][] graph={{0,0,0,0,0,1,1,1,1,1},{0,1,0,0,0,1,0,0,0,1},{0,0,0,0,0,1,0,0,0,1},{0,0,0,0,0,1,1,1,1,1},{0,0,0,0,0,0,0,0,0,0},{0,0,0,0,1,1,1,0,0,0},{0,0,0,1,1,1,1,1,0,0},{1,1,1,1,1,1,1,1,1,0}};
        //int[][] graph={{1,1,1,1,0},{1,1,0,0,0},{1,1,0,0,0},{0,0,0,0,0}}; 
        int[] res=solve(graph);
        System.out.println(res[1]);
    }
    static List<Integer> l1=new ArrayList<>();
    static List<Integer> l2=new ArrayList<>();
    public static int[] solve(int[][] graph)
    {

        int m=graph.length;
        int n=graph[0].length;
        int num=0;
        int max=0;
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(graph[i][j]==1)
                {
                    ++num;
                    dfs(graph,i,j);
                    //如何求map中的曼哈顿最大值  max
                    max=Math.max(max,maHaton(l1,l2));
                }
                 l1=new ArrayList<>();
                l2=new ArrayList<>();
            }
        }

        return new int[]{num,max};
    }
    public static void dfs(int[][]grid,int i,int j)
    {
        int m=grid.length;
        int n=grid[0].length;
        if(i<0||j<0||i>=m||j>=n||grid[i][j]==0)
        {
            return;
        }
        l1.add(i);
        l2.add(j);
        grid[i][j]=0;
        dfs(grid,i-1,j);
        dfs(grid,i+1,j);
        dfs(grid,i,j-1);
        dfs(grid,i,j+1);
    }
    public static int maHaton(List<Integer> l1,List<Integer> l2)
    {


        int []arr1=new int[l1.size()];
        int[] arr2=new int[l1.size()];
        for(int i=0;i<l1.size();i++)
        {
            arr1[i]=l1.get(i);
            arr2[i]=l2.get(i);
        }
        int amin=Integer.MAX_VALUE,bmin=Integer.MAX_VALUE,cmin=Integer.MAX_VALUE,dmin=Integer.MAX_VALUE;
        int amax=Integer.MIN_VALUE,bmax=Integer.MIN_VALUE,cmax=Integer.MIN_VALUE,dmax=Integer.MIN_VALUE;
        for(int i=0;i<arr1.length;i++)
        {
            amin=Math.min(amin,arr1[i]+arr2[i]);
            amax=Math.max(amax,arr1[i]+arr2[i]);

            bmin=Math.min(bmin,arr1[i]-arr2[i]);
            bmax=Math.max(bmax,arr1[i]-arr2[i]);

            cmin=Math.min(cmin,-arr1[i]+arr2[i]);
            cmax=Math.max(cmax,-arr1[i]+arr2[i]);
            dmin=Math.min(dmin,-arr1[i]-arr2[i]);
            dmax=Math.max(dmax,-arr1[i]-arr2[i]);
        }
        return Math.max(Math.max(amax-amin,bmax-bmin),Math.max(cmax-cmin,dmax-dmin));
    }