JAVA输入格式：第一行是两个以空格符分隔的整数n和m；接下来的第二行到第m+1行，每行包含4个以空格分开的元素x，y，w和d来描述一条道路，其中x和y是一条长度为w的道路相连的两个农场的编号，d是字符N.E.S.或W，表示从x到y的道路的方向。 输出格式：给出最远的一对农场之间距离的整数。

这是一道关于计算图中最长路径的问题，可以使用Dijkstra算法来解决。具体步骤如下：

1. 构建邻接表，用于存储图中的边和权值。

2. 初始化起点到其他点的距离为无穷大，起点到自己的距离为0。

3. 使用优先队列（最小堆）来存储待访问的节点，每次从队列中取出距离最小的节点进行松弛操作。

4. 对于每个节点，遍历与其相邻的节点，更新它们的距离。

5. 最终得到起点到其他点的最短距离，取其中的最大值即为图中最长路径。

代码实现如下：

import java.util.*;

public class Main {
    static class Edge {
        int to, w;

        public Edge(int to, int w) {
            this.to = to;
            this.w = w;
        }
    }

    static int n, m;
    static List<List<Edge>> graph = new ArrayList<>();
    static int[] dist;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        for (int i = 0; i < n; i++) {
            graph.add(new ArrayList<>());
        }
        for (int i = 0; i < m; i++) {
            int x = scanner.nextInt() - 1;
            int y = scanner.nextInt() - 1;
            int w = scanner.nextInt();
            char d = scanner.next().charAt(0);
            int distance = (d == 'N' || d == 'S') ? w : (int) (w * Math.sqrt(2));
            graph.get(x).add(new Edge(y, distance));
            graph.get(y).add(new Edge(x, distance));
        }
        dist = new int[n];
        Arrays.fill(dist, Integer.MIN_VALUE);
        dist[0] = 0;
        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> dist[b] - dist[a]);
        pq.offer(0);
        while (!pq.isEmpty()) {
            int u = pq.poll();
            for (Edge e : graph.get(u)) {
                if (dist[e.to] < dist[u] + e.w) {
                    dist[e.to] = dist[u] + e.w;
                    pq.offer(e.to);
                }
            }
        }
        int ans = Integer.MIN_VALUE;
        for (int i = 0; i < n; i++) {
            ans = Math.max(ans, dist[i]);
        }
        System.out.println(ans);
    }
}