可上 欧弟OJ系统 练习华子OD、大厂真题
绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
文章目录
- 相关推荐阅读
- **一、题目描述**
- **二、题目解析**
- **三、参考代码**
- Python
- Java
- C++
- **四、时空复杂度**
- 华为OD算法/大厂面试高频题算法练习冲刺训练
相关推荐阅读
- 全源最短路问题：Floyd算法详解【经典算法，限时免费】
- 【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【最短路问题】2024D-快递员的烦恼【欧弟算法】全网注释最详细分类最全的华为OD真题题解
一、题目描述
有 n 个城市，按从 0 到 n-1 编号。给你一个边数组 edges，其中 edges[i] = [from(i), to(i), weight(i)] 代表 from(i) 和 to(i)两个城市之间的双向加权边，距离阈值是一个整数 distanceThreshold。
返回在路径距离限制为 distanceThreshold 以内可到达城市最少的城市。如果有多个这样的城市，则返回编号最大的城市。
注意，连接城市 i 和 j 的路径的距离等于沿该路径的所有边的权重之和。
示例 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 <= 1001 <= edges.length <= n * (n - 1) / 2edges[i].length == 30 <= from(i) < to(i) < n1 <= 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
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;
}
}
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;
}
};
四、时空复杂度
时间复杂度：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了解更多
