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

这篇具有很好参考价值的文章主要介绍了单源最短路(只有一个起点)bfs,多源BFS,目录力扣675.为高尔夫比赛砍树,多源最短路问题:力扣542.01矩阵力扣1020.飞地的数量。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

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

多源最短路问题:

力扣542.01矩阵

力扣1020.飞地的数量


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

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

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

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;

}
}

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

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

多源最短路问题:

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

力扣542.01矩阵

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

正难,反易这个从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的原因单源最短路(只有一个起点)bfs,多源BFS,目录力扣675.为高尔夫比赛砍树,多源最短路问题:力扣542.01矩阵力扣1020.飞地的数量,宽度优先,算法

力扣1020.飞地的数量

单源最短路(只有一个起点)bfs,多源BFS,目录力扣675.为高尔夫比赛砍树,多源最短路问题:力扣542.01矩阵力扣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;
    }


}

单源最短路(只有一个起点)bfs,多源BFS,目录力扣675.为高尔夫比赛砍树,多源最短路问题:力扣542.01矩阵力扣1020.飞地的数量,宽度优先,算法文章来源地址https://www.toymoban.com/news/detail-849134.html

到了这里,关于单源最短路(只有一个起点)bfs,多源BFS,目录力扣675.为高尔夫比赛砍树,多源最短路问题:力扣542.01矩阵力扣1020.飞地的数量的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【图论】单源最短路

    算法提高课笔记 最短路问题可以分为以下两类: 边权非负——朴素Dijkstra、堆优化Dijkstra 有负权边——Bellman-Ford、SPFA 热浪 原题链接 德克萨斯纯朴的民众们这个夏天正在遭受巨大的热浪!!! 他们的德克萨斯长角牛吃起来不错,可是它们并不是很擅长生产富含奶油的乳制品

    2024年02月14日
    浏览(43)
  • 【图论 单源最短路】100276. 最短路径中的边

    单源最短路 图论知识汇总 给你一个 n 个节点的无向带权图,节点编号为 0 到 n - 1 。图中总共有 m 条边,用二维数组 edges 表示,其中 edges[i] = [ai, bi, wi] 表示节点 ai 和 bi 之间有一条边权为 wi 的边。 对于节点 0 为出发点,节点 n - 1 为结束点的所有最短路,你需要返回一个长度

    2024年04月22日
    浏览(34)
  • 算法提高-图论-单源最短路的综合应用

    多次dijkstra求每个点到其它点的最短距离, 此时相当于建好了一张图,每个点之间的最短距离都知道了,接下来dfs搜一下怎么走最短即可 一篇博客解释了为什么一个正向建图求最小值,反向建图求最大值 根本思想是保证1到n的买卖是连通的

    2024年02月11日
    浏览(60)
  • 算法提高-图论-单源最短路的扩展应用

    多源点单终点最短路建图: 创建虚拟源点(创建虚拟源点的时候以是spfa为例 可以在建图的时候建出来,也可以在spfa这直接入队,也是虚拟源点的意思) 反向建图变成单源点多终点,然后遍历终点的dist即可找出最短路 这题挺简单的就不详细说了,主要是第一次遇到计数问题

    2024年02月16日
    浏览(47)
  • 【算法】单源最短路径算法——Dijkstra算法

    迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959 年提出的,因此又叫狄克斯特拉算法。这是从一个顶点到其余各顶点的最短路径算法,解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始,采用 贪心算法 的策略, 每次遍历到始点距离最

    2024年02月05日
    浏览(44)
  • C++算法:单源最短路径Dijkstra

    如果你有一份北京地图,想从中关村走到三元桥,那么怎样能找出实现这一目的的最短路径呢?一种可能的方法就是将这两点之间所有的路线都找出来,然后求出每条路线的距离,找出最短的路线。但是仔细想想我们就会发现这种办法几乎是不可行的,因为这样的路线太多了,

    2024年02月09日
    浏览(43)
  • 最短路问题 Bellman-Ford(单源最短路径)(图解)

    对于边(u,v),用dist(u)和(u,v)的和尝试更新dist(v):                          dist(v) = min(dist(v) , dist(u)+l(u,v) 注:dist(i)为源点(起点)到i点的距离,l(u,v)为u-v的边权。 Bellman-Ford的基本操作是进行多次迭代,每一轮迭代对图上所有边进行松弛操作,直到

    2024年02月09日
    浏览(38)
  • 单源最短路径问题——分支限界法(Java)

    1.1 分支限界法求解目标 分支限界法与回溯法的不同求解目标: 回溯法的求解目标:找出解空间树中满足约束条件的 所有解 ; 分支限界法的求解目标:找出满足约束条件的 一个解 ,或是在满足约束条件的解中找出使用某一目标函数值达到极大或极小的解,即在某种意义下

    2024年02月06日
    浏览(35)
  • 迪杰斯特拉算法 – 图的单源最短路径

    迪杰斯特拉算法是由荷兰计算机科学家狄克斯特拉于1959 年提出的,因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法,解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止。迪杰斯特拉算法采

    2024年02月05日
    浏览(42)
  • 多源BFS-- 矩阵距离

      关于 多源BFS ,基本上就是单源BFS的简单升级了一下,比如在queue中队头开始时只有一个,我们通过这一个队头去推导其他的东西。而多源最短路就是队头一开始有1-n个可能的数,一个一个去BFS。 题目思路:         这个题就直接把所有的1统计出来放进queue中,每次取出对

    2024年02月15日
    浏览(30)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包