单源最短路(只有一个起点)bfs,多源BFS,目录力扣675.为高尔夫比赛砍树,多源最短路问题:力扣542.01矩阵力扣1020.飞地的数量

简介: 单源最短路(只有一个起点)bfs,多源BFS,目录力扣675.为高尔夫比赛砍树,多源最短路问题:力扣542.01矩阵力扣1020.飞地的数量

力扣675.为高尔夫比赛砍树

Collections.sort(trees,(a,b)->{

                  return f.get(a[0]).get(a[1])-f.get(b[0]).get(b[1]);

              });

这块比较难写

这段代码是Java中的一段代码,用于对名为trees的集合进行排序。这个集合很可能是一个列表(List),其中的元素是某种类型的数组(可能是二维数组或数组的数组)。排序的依据是另一个名为f的映射(可能是Map<K, Map<K, V>>类型的),其中V是实现了Comparable接口的类型(比如Integer或String),以便可以进行比较。

代码中的Collections.sort方法是一个静态方法,用于对列表进行排序。它接受两个参数:要排序的列表和一个Comparator对象,该对象定义了排序的规则。

这里的Comparator是通过lambda表达式定义的,它接受两个参数a和b,这两个参数都是trees列表中的元素(即数组)。lambda表达式返回的值用于决定a和b在排序后的列表中的相对位置。

具体来说,lambda表达式中的f.get(a[0]).get(a[1])和f.get(b[0]).get(b[1])从f映射中分别根据a和b的第一个和第二个元素作为键来获取对应的值。然后,这两个值相减,得到的结果用于确定a和b的顺序。

如果结果为负数,则a会被排在b之前。

如果结果为零,则a和b的顺序不变(但实际的排序稳定性取决于排序算法)。

如果结果为正数,则a会被排在b之后。

这段代码假设f映射中的每个键都对应一个非空的映射,且每个内部映射都包含所需的键,并且返回的值是可以相减的。如果这些假设不成立,代码可能会抛出异常。此外,这种排序方式依赖于f映射中值的自然顺序。如果值的类型没有实现Comparable接口,或者你想要使用不同的排序规则,那么你需要提供自定义的比较逻辑。

class Solution {
    static  int[]dx={0,0,1,-1};
    static int[]dy={1,-1,0,0};
    //1.确定砍树顺序
    public static int cutOffTree(List<List<Integer>> f){
        
   int  m=f.size(),n=f.get(0).size();
       List<int[]>trees=new ArrayList<>();
       for(int i=0;i<m;i++) {
           for (int j = 0; j < n; j++) {
               if (f.get(i).get(j) > 1) {
                //把需要砍的树都放到这个容器里面
                   trees.add(new int[]{i, j});
               }
           }
       }
       //容器的排序,需要去书写比较器
               Collections.sort(trees,(a,b)->{
                   return f.get(a[0]).get(a[1])-f.get(b[0]).get(b[1]);
               });
               //按照顺序砍树
               int ret=0;
               int bx=0,by=0;
               for(int[]tree:trees){
                //bx为当前坐标位置
                   int x=tree[0],y=tree[1];
                    //ex,ey为终点的坐标,也就是xy,trees是需要砍的树
                   int step=bfs(f,bx,by,x,y);
                   if(step==-1){
                       return -1;
                   }
                   ret+=step;
                   bx=x;
                   by=y;
               }
               return ret;
       }
      //常规的迷宫
public static int bfs(List<List<Integer>>f,int bx,int by,int ex,int ey) {
    if (bx == ex && by == ey) return 0;
    Queue<int[]> q = new LinkedList<>();
    int m = f.size(), n = f.get(0).size();
    boolean[][] vis = new boolean[m][n];
//标记当前值
    q.add(new int[]{bx, by});
//初始化标记
    vis[bx][by] = true;
    int step = 0;
    while (!q.isEmpty()) {
        step++;
        int sz = q.size();
//和上次一样,size是为了看
        while (sz != 0) {
            int[] t = q.poll();
//出当前队列
            int a = t[0], b = t[1];
            for (int i = 0; i < 4; i++) {
                int x = a + dx[i], y = b + dy[i];
//下标是否合法
                if (x >= 0 && y >= 0 && x < m && y < n && f.get(x).get(y) != 0 && vis[x][y] == false) {
//如果到达了位置,就可以直接返回step
                    if (x == ex && y == ey) return step;
                    q.add(new int[]{x, y});
                    vis[x][y] = true;
                }
            }
            sz--;
        }
    }
    return -1;
 
}
}

把前一个的博客心得放上面不知道能不能理解,他假如两个都合适的情况下,一个能到,一个还要再走一步再到,那么长的那个他会把下一步的点放到队列里面,然后那个短的直接就走完了,直接返回了,换句话说也算是比较,一定是最短。

多源最短路问题:

力扣542.01矩阵

正难,反易这个从1开始,把所有的1当成一个巨大的原子1,不太好实现

1.假如判断好距离后,哪个1是这个距离

所以我们把0看成一组,然后通过这组0来去遍历

class Solution {
    static  int[]dx={0,0,1,-1};
    static  int[]dy={1,-1,0,0};
    public  static int[][] updateMatrix(int[][] mat) {
        int m=mat.length,n=mat[0].length;
        Queue<int[]> q=new LinkedList<>();
        //dist两个作用-标记为-1当前位置没有被搜索过,!=-1存储的是最短的距离
        int dist[][]=new int[m][n];
        for(int i=0;i<m;i++){
            Arrays.fill(dist[i],-1);
        }
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++) {
                if(mat[i][j]==0){
                    dist[i][j]=0;
                    q.add(new int[]{i,j});
                }
            }
        while(!q.isEmpty()){
/因为队列是先进先出,所以下一个也会是初始化进入的那个
            //假如有sz是为了去找最短的路径距离(他是为了处理不同的起点造成的路径不同的情况,那么假如同时间两个不同的起点,假如最短的情况,那么他就会第一时间标记,标记成功之后,他就是那个最短的了)
             int []t=q.poll();
             int a=t[0], b=t[1];
             for(int i=0;i<4;i++){
                 int x=a+dx[i],y=b+dy[i];
                 if(x>=0&&x<m&&y>=0&&y<n&&dist[x][y]==-1){
                     //dist内部就去计数了,所以不需要这个step,
                     dist[x][y]=dist[a][b]+1;
                     q.add(new int[]{x,y});
                 }
             }
        }
    return dist;
    }
}

没有sz的原因

力扣1020.飞地的数量

解法1:一个一个去判断-超时

解法2:正难则反。(从边界的1开始出发,往里面走,只要边界上的1能走到里面的1,那么就打个标记,不用去计数

class Solution {
    
         static int[] dx = {0, 0, 1, -1};
    static int[] dy = {1, -1, 0, 0};
 
    public static int numEnclaves(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        int count = 0;
        Queue<int[]> q = new LinkedList<>();
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++) {
                if ((i == 0 || i == m - 1 || j == 0 || j == n - 1) && grid[i][j] == 1) {
                    //边界上的1我们不去算他,只去保存他的下标就好
                    grid[i][j]=100;
                    q.add(new int[]{i, j});
                }
            }
        while (!q.isEmpty()) {
            int sz = q.size();
            while (sz != 0) {
                int[] t = q.poll();
                int a = t[0], b = t[1];
                for (int i = 0; i < 4; i++) {
                    int x = a + dx[i], y = b + dy[i];
                    //检查这里面的假如是1,那么就说明我们能从边界到达,换句话说,他能够出去,那么我们就给他设置成-1,假如遍历不到的,那么就不去改变他
                    if (x >= 0 && y >= 0 && x < m && y < n && grid[x][y] == 1) {
                        q.add(new int[]{x, y});
                        grid[x][y] = -1;
                    }
                }
                sz--;
            }
        }
 
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++) {
                //只去遍历我们从边界到达不到的地方。
                if (grid[i][j] == 1)
                    count++;
            }
        return count;
    }
 
 
}
相关文章
|
20天前
|
算法
力扣经典150题第三十七题:矩阵置零
力扣经典150题第三十七题:矩阵置零
15 2
|
1月前
|
存储 数据采集 算法
LeetCode题目73:矩阵置零
LeetCode题目73:矩阵置零
|
20天前
力扣随机一题 6/28 数组/矩阵
力扣随机一题 6/28 数组/矩阵
15 0
|
1月前
|
算法
【经典LeetCode算法题目专栏分类】【第6期】二分查找系列:x的平方根、有效完全平方数、搜索二位矩阵、寻找旋转排序数组最小值
【经典LeetCode算法题目专栏分类】【第6期】二分查找系列:x的平方根、有效完全平方数、搜索二位矩阵、寻找旋转排序数组最小值
|
1月前
|
算法
【经典LeetCode算法题目专栏分类】【第4期】BFS广度优先算法:单词接龙、最小基因变化、二进制矩阵中的最短路径
【经典LeetCode算法题目专栏分类】【第4期】BFS广度优先算法:单词接龙、最小基因变化、二进制矩阵中的最短路径
|
1月前
|
存储 算法 数据可视化
广度优先搜索(BFS)+回溯解决LeetCode 126题:单词接龙 II
广度优先搜索(BFS)+回溯解决LeetCode 126题:单词接龙 II
|
1月前
|
SQL 算法 数据可视化
LeetCode题目99:图解中叙遍历、Morris遍历实现恢复二叉树搜索树【python】
LeetCode题目99:图解中叙遍历、Morris遍历实现恢复二叉树搜索树【python】
|
1月前
|
存储 SQL 算法
LeetCode题目100:递归、迭代、dfs使用栈多种算法图解相同的树
LeetCode题目100:递归、迭代、dfs使用栈多种算法图解相同的树
|
1月前
|
存储 算法 数据可视化
python多种算法对比图解实现 验证二叉树搜索树【力扣98】
python多种算法对比图解实现 验证二叉树搜索树【力扣98】
|
1月前
|
存储 算法 数据可视化
LeetCode 题目 97:动态规划、递归到广度优先搜索BFS 实现交错字符串
LeetCode 题目 97:动态规划、递归到广度优先搜索BFS 实现交错字符串