当前位置:   article > 正文

【Py/Java/C++三种语言详解】LeetCode 1334、LeetCode1334. 阈值距离内邻居最少的城市【全源最短路问题Floyd算法】

【Py/Java/C++三种语言详解】LeetCode 1334、LeetCode1334. 阈值距离内邻居最少的城市【全源最短路问题Floyd算法】

可上 欧弟OJ系统 练习华子OD、大厂真题
绿色聊天软件od1441了解算法冲刺训练(备注【CSDN】否则不通过)

相关推荐阅读

一、题目描述

n 个城市,按从 0n-1 编号。给你一个边数组 edges,其中 edges[i] = [from(i), to(i), weight(i)] 代表 from(i)to(i)两个城市之间的双向加权边,距离阈值是一个整数 distanceThreshold

返回在路径距离限制为 distanceThreshold 以内可到达城市最少的城市。如果有多个这样的城市,则返回编号最大的城市。

注意,连接城市 ij 的路径的距离等于沿该路径的所有边的权重之和。

示例 1

在这里插入图片描述

输入:n = 4, edges = [[0,1,3],[1,2,1],[1,3,4],[2,3,1]], distanceThreshold = 4
输出:3
解释:城市分布图如上。 每个城市阈值距离 distanceThreshold = 4 内的邻居城市分别是:
城市 0 -> [城市 1, 城市 2]
城市 1 -> [城市 0, 城市 2, 城市 3]
城市 2 -> [城市 0, 城市 1, 城市 3]
城市 3 -> [城市 1, 城市 2]
城市 0 和 3 在阈值距离 4 以内都有 2 个邻居城市,但是我们必须返回城市 3,因为它的编号最大。

示例 2

在这里插入图片描述

输入:n = 5, edges = [[0,1,2],[0,4,8],[1,2,3],[1,4,2],[2,3,1],[3,4,1]], distanceThreshold = 2
输出:0
解释:城市分布图如上。 每个城市阈值距离 distanceThreshold = 2 内的邻居城市分别是:
城市 0 -> [城市 1]
城市 1 -> [城市 0, 城市 4]
城市 2 -> [城市 3, 城市 4]
城市 3 -> [城市 2, 城市 4]
城市 4 -> [城市 1, 城市 2, 城市 3]
城市 0 在阈值距离 2 以内只有 1 个邻居城市。

提示

  • 2 <= n <= 100
  • 1 <= edges.length <= n * (n - 1) / 2
  • edges[i].length == 3
  • 0 <= from(i) < to(i) < n
  • 1 <= weight(i), distanceThreshold <= 10^4
  • 所有 (from(i), to(i)) 都是不同的。

二、题目解析

本题的设问是,希望找到在阈值距离范围内能到达城市最少的城市编号

这意味着,这个最短路问题并不是求特定起点到特定终点的距离,而是要考虑不同的起点和不同的终点

因此是一个全源最短路径问题,应该使用Floyd算法来解决。

关于全源最短路问题的Floyd算法的详细解释,可以查看2024/08/03 真题讲解(最短路问题Floyd算法专题)

三、参考代码

Python

# 题目:LeetCode1334. 阈值距离内邻居最少的城市
# 作者:闭着眼睛学数理化
# 算法:最短路问题-Floyd算法
# 代码看不懂的地方,请直接在群上提问


class Solution:
    def findTheCity(self, n: int, edges: List[List[int]], distanceThreshold: int) -> int:
        grid = [n * [inf] for _ in range(n)]
        # 初始化,grid[a][b]表示从a到b的最短路径
        for a, b, w in edges:
            grid[a][b], grid[b][a] = w, w
        # grid数组的对角线均为0,表示从节点i到达其自身的路径为0
        for i in range(n):
            grid[i][i] = 0
        
        # 枚举所有中间点(插点)
        for mid in range(n):
            # 枚举起始点
            for start in range(n):
                # 枚举终点
                for end in range(n):
                    # 动态转移方程:如果直接从start到end的最短路径,不如先从start再到mid再到end的距离短
                    # 则更新grid[start][end]。
                    if grid[start][end] > grid[start][mid] + grid[mid][end]:
                        grid[start][end] = grid[start][mid] + grid[mid][end]
                        grid[end][start] = grid[start][mid] + grid[mid][end]

        ans, min_num = -1, inf
        # 再次遍历所有节点i
        for i in range(n):
            # 计算从节点i出发,其最短距离小于阈值distanceThreshold的其他节点数目
            # -1表示刨除其自身的影响,本题其实不-1也可以
            num = sum(dis <= distanceThreshold for dis in grid[i]) - 1
            if min_num >= num:
                ans = i
                min_num = num
        return ans
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38

Java

class Solution {
    public int findTheCity(int n, int[][] edges, int distanceThreshold) {
        // 初始化,grid[a][b]表示从a到b的最短路径,填充一个大数
        int[][] grid = new int[n][n];
        for (int[] row : grid) {
            Arrays.fill(row, 1000000);
        }
        for (int[] edge : edges) {
            int a = edge[0], b = edge[1], w = edge[2];
            grid[a][b] = w;
            grid[b][a] = w;
        }
        // grid数组的对角线均为0,表示从节点i到达其自身的路径为0
        for (int i = 0; i < n; i++){
            grid[i][i] = 0;
        }

        // 枚举所有中间点(插点)
        for (int mid = 0; mid < n; mid++) {
            // 枚举起始点
            for (int start = 0; start < n; start++) {
                // 枚举终点
                for (int end = 0; end < n; end++) {
                    // 动态转移方程:如果直接从start到end的最短路径,不如先从start再到mid再到end的距离短
                    // 则更新grid[start][end]。
                    if (grid[start][end] > grid[start][mid] + grid[mid][end]) {
                        grid[start][end] = grid[start][mid] + grid[mid][end];
                        grid[end][start] = grid[start][mid] + grid[mid][end];
                    }
                }
            }
        }

        int ans = -1, min_num = Integer.MAX_VALUE;
        // 再次遍历所有节点i
        for (int i = 0; i < n; i++) {
            int num = 0;
            // 计算从节点i出发,其最短距离小于阈值distanceThreshold的其他节点数目
            for (int dis : grid[i]) {
                if (dis <= distanceThreshold) {
                    num++;
                }
            }
            if (min_num >= num) {
                ans = i;
                min_num = num;
            }
        }
        return ans;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

C++

class Solution {
public:
    int findTheCity(int n, vector<vector<int>>& edges, int distanceThreshold) {
        // 初始化图,grid[a][b]表示从a到b的最短路径,填充一个大数
        vector<vector<int>> grid(n, vector<int>(n, 1000000));
        for (auto& edge : edges) {
            int a = edge[0], b = edge[1], w = edge[2];
            grid[a][b] = w;
            grid[b][a] = w;
        }
        // grid数组的对角线均为0,表示从节点i到达其自身的路径为0
        for (int i = 0; i < n; i++){
            grid[i][i] = 0;
        }

        // 枚举所有中间点(插点)
        for (int mid = 0; mid < n; ++mid) {
            // 枚举起始点
            for (int start = 0; start < n; ++start) {
                // 枚举终点
                for (int end = 0; end < n; ++end) {
                    // 动态转移方程:如果直接从start到end的最短路径,不如先从start再到mid再到end的距离短
                    // 则更新grid[start][end]。
                    if (grid[start][end] > grid[start][mid] + grid[mid][end]) {
                        grid[start][end] = grid[start][mid] + grid[mid][end];
                        grid[end][start] = grid[start][mid] + grid[mid][end];
                    }
                }
            }
        }

        int ans = -1, min_num = INT_MAX;
        // 再次遍历所有节点i
        for (int i = 0; i < n; ++i) {
            // 计算从节点i出发,其最短距离小于阈值distanceThreshold的其他节点数目
            int num = count_if(grid[i].begin(), grid[i].end(), [distanceThreshold](int dis) { return dis <= distanceThreshold; });
            if (min_num >= num) {
                ans = i;
                min_num = num;
            }
        }
        return ans;
    }
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

四、时空复杂度

时间复杂度:O(N^3)。三重循环所需时间复杂度。

空间复杂度:O(N^2)。最小距离矩阵所占空间。

其中N为节点数目。


华为OD算法/大厂面试高频题算法练习冲刺训练

  • 华为OD算法/大厂面试高频题算法冲刺训练目前开始常态化报名!目前已服务300+同学成功上岸!

  • 课程讲师为全网50w+粉丝编程博主@吴师兄学算法 以及小红书头部编程博主@闭着眼睛学数理化

  • 每期人数维持在20人内,保证能够最大限度地满足到每一个同学的需求,达到和1v1同样的学习效果!

  • 60+天陪伴式学习,40+直播课时,300+动画图解视频,300+LeetCode经典题,200+华为OD真题/大厂真题,还有简历修改、模拟面试、专属HR对接将为你解锁

  • 可上全网独家的欧弟OJ系统练习华子OD、大厂真题

  • 可查看链接 大厂真题汇总 & OD真题汇总(持续更新)

  • 绿色聊天软件戳 od1336了解更多

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/木道寻08/article/detail/924192
推荐阅读
相关标签
  

闽ICP备14008679号