解题思路

这个问题可以转化为：在所有农场到农场 $1$ 的最短路径中，找到路径上的最长道路的最大值。即，我们需要计算从农场 $1$ 到所有其他农场的最短路径，并在这些路径中找到最长的那条边的长度。

关键点：

$1、$最短路径中的最长边：对于每个农场，找到从农场 $1$ 到该农场的最短路径，然后在这些路径中找出最长的那条边。

$2、Dijkstra$ 算法的变种：在计算最短路径时，同时记录路径上的最长边的长度。

算法步骤：

$1、$构建图：将农场和道路表示为图，农场为节点，道路为边，长度为边的权重。

$2、Dijkstra$ 算法：从农场 $1$ 出发，计算到所有其他农场的最短路径，并在过程中记录路径上的最长边的长度。

$3、$收集结果：对于每个农场，记录其最短路径上的最长边的长度，然后在这些长度中取最大值。

#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <string.h>
 
using namespace std;
 
const int N = 2000;
const int M = 10000;
 
int f[N + 1];
 
void UFInit(int n)
{
    for(int i = 1; i <=n; i++)
        f[i] = i;
}
 
int Find(int a) {
    return a == f[a] ? a : f[a] = Find(f[a]);
}
 
bool Union(int a, int b)
{
    a = Find(a);
    b = Find(b);
    if (a != b) {
        f[a] = b;
        return true;
    } else
        return false;
}
 
struct Edge {
    int u, v, w;
} edges[M];
 
bool cmp(Edge a, Edge b)
{
    return a.w < b.w;
}
 
int main()
{
    int n, m;
    while(~scanf("%d%d", &n, &m)) {
        UFInit(n);
 
        for(int i = 0; i < m; i++)
            scanf("%d%d%d", &edges[i].u, &edges[i].v, &edges[i].w);
 
        // Kruscal算法
       int maxw = 0, cnt = 0;
       sort(edges, edges + m, cmp);
       for(int i = 0; i < m; i++) {
           if(Union(edges[i].u, edges[i].v)) {
               if(edges[i].w > maxw)
                   maxw = edges[i].w;
               if(++cnt == n - 1)
                   break;
           }
       }
 
       printf("%d\n", maxw);
    }
 
    return 0;
}