Leetcode1334. 阈值距离内邻居最少的城市

Every day a Leetcode

题目来源：1334. 阈值距离内邻居最少的城市

解法1：Floyd 算法

使用 Floyd 算法得到任意两点之间的最短路，然后统计每一个节点满足条件（距离在 distanceThreshold 以内）的邻居数量。

代码：

/*
 * @lc app=leetcode.cn id=1334 lang=cpp
 *
 * [1334] 阈值距离内邻居最少的城市
 */

// @lc code=start

// Floyd 算法

class Solution
{
public:
    int findTheCity(int n, vector<vector<int>> &edges, int distanceThreshold)
    {
        // 初始化邻接矩阵
        vector<vector<int>> grid(n, vector<int>(n, INT_MAX / 2));
        // 建图
        for (vector<int> &edge : edges)
        {
            int from = edge[0], to = edge[1], weight = edge[2];
            grid[from][to] = grid[to][from] = weight;
        }
        // 求最短路
        for (int k = 0; k < n; k++)
        {
            grid[k][k] = 0;
            for (int i = 0; i < n; i++)
                for (int j = 0; j < n; j++)
                    grid[i][j] = min(grid[i][j], grid[i][k] + grid[k][j]);
        }
        // 求答案
        pair<int, int> ans(INT_MAX / 2, -1);
        for (int i = 0; i < n; i++)
        {
            int count = 0;
            for (int j = 0; j < n; j++)
                if (grid[i][j] <= distanceThreshold)
                    count++;
            if (count <= ans.first)
                ans = make_pair(count, i);
        }
        return ans.second;
    }
};
// @lc code=end

结果：

复杂度分析：

时间复杂度：O(n³)，其中 n 是图中节点个数。Floyd 算法使用每一个节点对任意两个节点进行松弛操作。

空间复杂度：O(n²)，其中 n 是图中节点个数。使用邻接矩阵存储任意两点之间的距离。

解法2：Dijkstra 算法

我们可以对每一个节点求解单源最短路，即某一个节点到其它所有节点的最短距离。

朴素的 Dijkstra 算法不断使用距离最近的节点来松弛到其它节点的距离。

代码：

class Solution {
public:
    int findTheCity(int n, vector<vector<int>> &edges, int distanceThreshold) {
        pair<int, int> ans(INT_MAX / 2, -1);
        vector<vector<int>> dis(n, vector<int>(n, INT_MAX / 2));
        vector<vector<int>> vis(n, vector<int>(n, false));
        vector<vector<int>> mp(n, vector<int>(n, INT_MAX / 2));
        for (auto &eg: edges) {
            int from = eg[0], to = eg[1], weight = eg[2];
            mp[from][to] = mp[to][from] = weight;
        }
        for (int i = 0; i < n; ++i) {
            dis[i][i] = 0;
            for (int j = 0; j < n; ++j) {
                int t = -1;
                for (int k = 0; k < n; ++k) {
                    if (!vis[i][k] && (t == -1 || dis[i][k] < dis[i][t])) {
                        t = k;
                    }
                }
                for (int k = 0; k < n; ++k) {
                    dis[i][k] = min(dis[i][k], dis[i][t] + mp[t][k]);
                }
                vis[i][t] = true;
            }
        }
        for (int i = 0; i < n; ++i) {
            int cnt = 0;
            for (int j = 0; j < n; ++j) {
                if (dis[i][j] <= distanceThreshold) {
                    cnt++;
                }
            }
            if (cnt <= ans.first) {
                ans = {cnt, i};
            }
        }
        return ans.second;
    }
};

结果：

复杂度分析：

时间复杂度：O(n³)，其中 n 是图中节点个数。对图中的每一个节点执行 Dijkstra 算法。Dijkstra 算法使用每一个顶点对当前节点到其它节点之间的距离进行松弛。

空间复杂度：O(n²)，其中 n 是图中节点个数。使用邻接矩阵存储任意两点之间的距离。