有n个股票经纪人，股票经纪人要在一群人中散布一个传言，要求时间最短。第i个人向其他人散布传言的时间不同，但是，是同时传播的，也就是说取其最大值。

这是一个经典的问题，可以用分治法来解决。具体步骤如下：

1. 将所有股票经纪人分为两组，递归地求解每一组的传播时间。

2. 对于每一组，选出传播时间最长的经纪人。

3. 将这些经纪人加入一个新的组，递归地求解这个新组的传播时间。

4. 最终的传播时间是所有组中传播时间最长的经纪人的传播时间。

代码示例：

def rumor_spreading(brokers):
    if len(brokers) == 1:
        return brokers[0]
    mid = len(brokers) // 2
    left = rumor_spreading(brokers[:mid])
    right = rumor_spreading(brokers[mid:])
    max_time = max(left, right)
    for i in range(mid):
        max_time = max(max_time, brokers[i])
    return max_time

brokers = [3, 5, 1, 7, 2, 8, 4, 6]
print(rumor_spreading(brokers)) # 输出 8

在这个例子中，我们有8个股票经纪人，他们的传播时间分别是3、5、1、7、2、8、4和6。最终的传播时间是8。

相关问题

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 是人的数量。

Java求解股票经纪人KK想要在一群人（n个人的编号为0~n-1）中散布一个传言，传言只通过认识的人进行传递，在两个认识的人之间传递消息所需要的时间各有不同，在一群人中，KK想要找出以哪个人为起点开始传递这个传言，可以在耗时最短的情况下认所有人都收到消息。

这是一个经典的最短路问题，可以使用 Dijkstra 算法或者 Floyd 算法来解决。

以下是 Dijkstra 算法的实现：

1. 初始化距离数组 dis，将起点的距离设为 0，其他点的距离设为无穷大。
2. 初始化一个集合 visited，用于记录已经找到最短路径的点。
3. 遍历所有节点，每次找到距离起点最近的未访问过的节点，将其加入 visited 集合中。
4. 对于当前节点的所有邻居节点，更新其距离起点的最短距离，如果更新后的距离更小，则更新距离数组 dis 中的值。
5. 重复步骤 3 和 4，直到所有节点都被访问过。

Java 代码实现如下：

import java.util.Arrays;

public class Broker {
    public static void main(String[] args) {
        int n = 5; // 节点个数
        int[][] graph = {{0, 1, 2, 3, 4}, {1, 0, 5, Integer.MAX_VALUE, Integer.MAX_VALUE},
                {2, 5, 0, 6, Integer.MAX_VALUE}, {3, Integer.MAX_VALUE, 6, 0, 7}, {4, Integer.MAX_VALUE, Integer.MAX_VALUE, 7, 0}}; // 邻接矩阵表示图

        int[] dis = new int[n]; // 距离数组，存储起点到各个节点的距离
        Arrays.fill(dis, Integer.MAX_VALUE);
        dis[0] = 0;

        boolean[] visited = new boolean[n]; // 标记数组，记录节点是否已经找到最短路径
        visited[0] = true;

        for (int i = 1; i < n; i++) {
            int minDis = Integer.MAX_VALUE;
            int minNode = -1;
            for (int j = 0; j < n; j++) {
                if (!visited[j] && dis[j] < minDis) {
                    minDis = dis[j];
                    minNode = j;
                }
            }
            if (minNode == -1) break;
            visited[minNode] = true;
            for (int j = 0; j < n; j++) {
                if (!visited[j] && graph[minNode][j] != Integer.MAX_VALUE && dis[minNode] + graph[minNode][j] < dis[j]) {
                    dis[j] = dis[minNode] + graph[minNode][j];
                }
            }
        }

        int maxDis = 0; // 找到最大距离
        int start = 0; // 找到起点
        for (int i = 0; i < n; i++) {
            if (dis[i] > maxDis) {
                maxDis = dis[i];
                start = i;
            }
        }

        System.out.println("起点为 " + start);
    }
}

其中，graph 数组表示邻接矩阵，dis 数组表示距离数组，visited 数组表示标记数组。程序输出的结果即为起点的编号。