求解股票经纪人问题[问题描述]股经纪人要在一群人(n 个人的编号为0~n-1)中散布一个传言,传言只在认识的人中间传递。题目中给出了人与人的认识关系以及传言在某两个认识的人中传递所需要的时间，编写程序求出以哪个人为起点可以在耗时最短的情况下让所有人收到消息 大验题 例如,n-4(人数),m=4(边数) 用java

这是一个经典的图论问题，可以使用 Dijkstra 算法或 Floyd 算法解决。

以下是使用 Dijkstra 算法的 Java 代码实现：

import java.util.Arrays;

public class StockBroker {
    public static int findShortestPath(int n, int[][] edges) {
        int[][] graph = new int[n][n];
        for (int[] row : graph) {
            Arrays.fill(row, Integer.MAX_VALUE);
        }
        for (int[] edge : edges) {
            graph[edge[0]][edge[1]] = edge[2];
            graph[edge[1]][edge[0]] = edge[2];
        }
        int[] dist = new int[n];
        boolean[] visited = new boolean[n];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[0] = 0;
        for (int i = 0; i < n; i++) {
            int u = -1;
            for (int j = 0; j < n; j++) {
                if (!visited[j] && (u == -1 || dist[j] < dist[u])) {
                    u = j;
                }
            }
            visited[u] = true;
            for (int v = 0; v < n; v++) {
                if (graph[u][v] != Integer.MAX_VALUE) {
                    dist[v] = Math.min(dist[v], dist[u] + graph[u][v]);
                }
            }
        }
        int maxDist = 0;
        for (int d : dist) {
            maxDist = Math.max(maxDist, d);
        }
        return maxDist == Integer.MAX_VALUE ? -1 : maxDist;
    }

    public static void main(String[] args) {
        int n = 4;
        int[][] edges = {{0, 1, 2}, {1, 2, 1}, {2, 3, 3}, {3, 0, 4}};
        System.out.println(findShortestPath(n, edges)); // output: 4
    }
}

其中，`n` 表示人数，`edges` 表示认识关系和传递时间，`graph` 表示传递时间的邻接矩阵，`dist` 表示从起点到各个点的最短时间，`visited` 表示该点是否已经被访问过。Dijkstra 算法的时间复杂度为 $O(n^2)$，适用于稠密图。

如果使用 Floyd 算法，可以通过以下 Java 代码实现：

import java.util.Arrays;

public class StockBroker {
    public static int findShortestPath(int n, int[][] edges) {
        int[][] graph = new int[n][n];
        for (int[] row : graph) {
            Arrays.fill(row, Integer.MAX_VALUE);
        }
        for (int[] edge : edges) {
            graph[edge[0]][edge[1]] = edge[2];
            graph[edge[1]][edge[0]] = edge[2];
        }
        for (int k = 0; k < n; k++) {
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    graph[i][j] = Math.min(graph[i][j], graph[i][k] + graph[k][j]);
                }
            }
        }
        int maxDist = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                maxDist = Math.max(maxDist, graph[i][j]);
            }
        }
        return maxDist == Integer.MAX_VALUE ? -1 : maxDist;
    }

    public static void main(String[] args) {
        int n = 4;
        int[][] edges = {{0, 1, 2}, {1, 2, 1}, {2, 3, 3}, {3, 0, 4}};
        System.out.println(findShortestPath(n, edges)); // output: 4
    }
}

其中，Floyd 算法的时间复杂度为 $O(n^3)$，适用于稠密图和稀疏图。