Java求解股票经纪人问题。股票经纪人要在一群人（n个人的编号为0~n-1）中散布一个传言，传言只在认识的人中间传递。题目中给出了人与人的认识关系以及传言在某两个认识的人中传递需要的时间。编写程序求出以哪个人为起点可以在耗时最短的情况下让所有人收到消息的具体代码

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

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

import java.util.*;

public class BrokerProblem {
    private static final int INF = Integer.MAX_VALUE;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[][] graph = new int[n][n];
        for (int i = 0; i < n; i++) {
            Arrays.fill(graph[i], INF);
            graph[i][i] = 0;
        }
        for (int i = 0; i < m; i++) {
            int u = sc.nextInt();
            int v = sc.nextInt();
            int w = sc.nextInt();
            graph[u][v] = graph[v][u] = w;
        }
        int minTime = INF;
        int start = -1;
        for (int i = 0; i < n; i++) {
            int time = dijkstra(graph, i);
            if (time < minTime) {
                minTime = time;
                start = i;
            }
        }
        System.out.println(start + " " + minTime);
    }

    private static int dijkstra(int[][] graph, int start) {
        int n = graph.length;
        boolean[] visited = new boolean[n];
        int[] dist = new int[n];
        Arrays.fill(dist, INF);
        dist[start] = 0;
        PriorityQueue<Node> pq = new PriorityQueue<>();
        pq.offer(new Node(start, 0));
        while (!pq.isEmpty()) {
            Node node = pq.poll();
            int u = node.vertex;
            if (visited[u]) {
                continue;
            }
            visited[u] = true;
            for (int v = 0; v < n; v++) {
                if (graph[u][v] != INF && !visited[v]) {
                    int alt = dist[u] + graph[u][v];
                    if (alt < dist[v]) {
                        dist[v] = alt;
                        pq.offer(new Node(v, dist[v]));
                    }
                }
            }
        }
        int maxTime = 0;
        for (int i = 0; i < n; i++) {
            if (dist[i] == INF) {
                return INF;
            }
            maxTime = Math.max(maxTime, dist[i]);
        }
        return maxTime;
    }

    private static class Node implements Comparable<Node> {
        int vertex;
        int dist;

        public Node(int vertex, int dist) {
            this.vertex = vertex;
            this.dist = dist;
        }

        public int compareTo(Node other) {
            return Integer.compare(dist, other.dist);
        }
    }
}

输入格式为：

n m
u1 v1 w1
u2 v2 w2
...
um vm wm

其中，n 表示人的数量，m 表示认识关系的数量，后面 m 行表示每一对认识的人以及它们之间传递传言需要的时间。

输出格式为：

start minTime

其中，start 表示起点人的编号，minTime 表示所有人收到消息需要的最短时间。

时间复杂度为 O(n^2 log n)，其中 n 是人的数量。