LeetCode刷题记录之Floyd(弗洛伊达算法)

 目录

 一.1334：阈值距离内邻居最少的城市

题目描述：

代码：

 测试代码：

二.743：网络延迟时间

题目描述：

代码：

 测试代码：

总结

---

 一.1334：阈值距离内邻居最少的城市

题目描述：

有 n 个城市，按从 0 到 n-1 编号。给你一个边数组 edges，其中 edges[i] = [fromi, toi, weighti] 代表 fromi 和 toi 两个城市之间的双向加权边，距离阈值是一个整数 distanceThreshold。

返回能通过某些路径到达其他城市数目最少、且路径距离 最大 为 distanceThreshold 的城市。如果有多个这样的城市，则返回编号最大的城市。

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

代码：

import java.util.Arrays;

//有 n 个城市，按从 0 到 n-1 编号。给你一个边数组 edges，
// 其中 edges[i] = [fromi, toi, weighti] 代表 fromi 和 toi 两个城市之间的双向加权边，
// 距离阈值是一个整数 distanceThreshold。
//
//返回能通过某些路径到达其他城市数目最少、且路径距离 最大 为 distanceThreshold 的城市。
// 如果有多个这样的城市，则返回编号最大的城市。
//
//注意，连接城市 i 和 j 的路径的距离等于沿该路径的所有边的权重之和。
public class Solution {
    public int findTheCity(int n, int[][] edges, int distanceThreshold) {
        //初始化距离矩阵，矩阵中坐标为(i,j)的值代表了城市i到城市j的距离。
        int[][] distance = new int[n][n];
        for (int i = 0; i < n; i++) {
            Arrays.fill(distance[i], Integer.MAX_VALUE);//首先用最大值填充矩阵，
            distance[i][i] = 0;//之后，将城市i到城市i的距离设为0，完成初始化。
        }
        //将给定的edges写入distance矩阵,将edges中的每个元素数组的前两个值作为矩阵中的坐标，将第三个表示距离的值写入矩阵。
        for (int[] array : edges) {
            int x = array[0];
            int y = array[1];
            int value = array[2];
            distance[x][y] = value;
            distance[y][x] = value;//注意图中每条边是无向的，i->j的距离 = j->i的距离。
        }
        //Floyd遍历矩阵,得到从任意两个城市之间的距离。
        for (int k = 0; k < n; k++) {//遍历中间城市
            for (int i = 0; i < n; i++) {//遍历出发城市
                for (int j = 0; j < n; j++) {//遍历到达城市
                    int distance_ik = distance[i][k];//出发城市到中间城市的距离
                    int distance_kj = distance[k][j];//中间城市到到达城市的距离
                    //首先通过Integer.MAX_VALUE判断路径是否存在，之后通过比较得到最小值
                    if (distance_ik != Integer.MAX_VALUE && distance_kj != Integer.MAX_VALUE) {
                        distance[i][j] = Math.min(distance_ik + distance_kj, distance[i][j]);
                    }
                }
            }
        }
        //寻找能通过某些路径到达其他城市数目最少、且路径距离 最大 为 distanceThreshold 的城市
        int min = Integer.MAX_VALUE;//记录到达城市数目最少值
        int city = -1;//记录城市序号
        for (int i = 0; i < n; i++) {
            int num = 0;//记录城市数目
            for (int j = 0; j < n; j++) {
                if (distance[i][j]<=distanceThreshold){
                    num++;
                }
            }
            if (num<=min){
                min = num;
                city = i;
            }
        }
        return city;
    }
}

 测试代码：

public class Test {
    public static void main(String[] args) {
        int n = 5;
        int distanceThreshold = 2;
        int[][] edges = new int[6][3];
        edges[0] = new int[]{0, 1, 2};
        edges[1] = new int[]{0, 4, 8};
        edges[2] = new int[]{1, 2, 3};
        edges[3] = new int[]{1, 4, 2};
        edges[4] = new int[]{2, 3, 1};
        edges[5] = new int[]{3, 4, 1};
        Solution s = new Solution();
        int theCity = s.findTheCity(n, edges, distanceThreshold);
        System.out.println(theCity);
    }
}

---

二.743：网络延迟时间

题目描述：

有 n 个网络节点，标记为 1 到 n。

给你一个列表 times，表示信号经过 有向 边的传递时间。 times[i] = (ui, vi, wi)，其中 ui 是源节点，vi 是目标节点， wi 是一个信号从源节点传递到目标节点的时间。

现在，从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 -1 。

代码：

import java.util.Arrays;
//有 n 个网络节点，标记为 1 到 n。
//
//给你一个列表 times，表示信号经过 有向 边的传递时间。
// times[i] = (ui, vi, wi)，其中 ui 是源节点，vi 是目标节点， wi 是一个信号从源节点传递到目标节点的时间。
//
//现在，从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 -1
public class Solution {
    public int networkDelayTime(int[][] times, int n, int k) {
        //初始化
        int[][] time = new int[n][n];
        //初始化时间矩阵
        for (int i = 0; i < n; i++) {
            Arrays.fill(time[i], Integer.MAX_VALUE);
            time[i][i] = 0;
        }
        //时间矩阵赋值
        for (int[] arr : times) {
            time[arr[0] - 1][arr[1] - 1] = arr[2];
        }
        //遍历矩阵
        for (int p = 0; p < n; p++) {//中间节点
            for (int i = 0; i < n; i++) {//出发节点
                for (int j = 0; j < n; j++) {//到达节点
                    if (time[i][p] != Integer.MAX_VALUE && time[p][j] != Integer.MAX_VALUE) {
                        time[i][j] = Math.min(time[i][p] + time[p][j], time[i][j]);
                    }
                }
            }
        }
        int index = k-1;
        Arrays.sort(time[index]);
        int result;
        if (time[index][n-1]!= Integer.MAX_VALUE) {
            result = time[index][n-1];
        }else {
            result = -1;
        }
        return result;
    }
}

 测试代码：

public class Demo {
    public static void main(String[] args) {
        int [][] times = new int[3][3];
        times[0] = new int[]{2,1,1};
        times[1] = new int[]{2,3,1};
        times[2] = new int[]{3,4,1};
        Solution s = new Solution();
        int i = s.networkDelayTime(times, 4, 2);
        System.out.println(i);

    }
}

---

总结

新手上路，代码很粗糙。(⊙﹏⊙)