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

这道题目需要使用图论中的最短路算法来解决，可以使用Dijkstra算法或者Bellman-Ford算法。

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

import java.util.*;

public class Main {
    static int n, m; // 农场数量和道路数量
    static List<int[]>[] edges; // 存储图的邻接表
    static int[] dist; // 存储从起点到每个点的最短距离

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        edges = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) {
            edges[i] = new ArrayList<>();
        }
        for (int i = 0; i < m; i++) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            int w = scanner.nextInt();
            char d = scanner.next().charAt(0);
            int distance = (d == 'N' || d == 'S') ? w : (int) (w * Math.sqrt(2));
            edges[x].add(new int[]{y, distance});
            edges[y].add(new int[]{x, distance});
        }

        dist = new int[n + 1];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dijkstra(1);

        int maxDist = 0;
        for (int i = 1; i <= n; i++) {
            if (dist[i] != Integer.MAX_VALUE && dist[i] > maxDist) {
                maxDist = dist[i];
            }
        }
        System.out.println(maxDist);
    }

    // Dijkstra算法求最短路
    private static void dijkstra(int start) {
        PriorityQueue<int[]> queue = new PriorityQueue<>((a, b) -> a[1] - b[1]);
        queue.offer(new int[]{start, 0});
        dist[start] = 0;
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int u = cur[0], distance = cur[1];
            if (distance > dist[u]) {
                continue;
            }
            for (int[] edge : edges[u]) {
                int v = edge[0], w = edge[1];
                if (dist[v] > dist[u] + w) {
                    dist[v] = dist[u] + w;
                    queue.offer(new int[]{v, dist[v]});
                }
            }
        }
    }
}

首先读入农场数量和道路数量，并创建邻接表。然后读入每条道路的信息，计算道路长度，将道路加入邻接表中。接下来使用Dijkstra算法求出从起点到每个点的最短距离，最终输出最远的一对农场之间距离。

注意，在计算道路长度时需要根据方向进行判断，如果是NS方向，则长度为w；如果是WE方向，则长度为w * sqrt(2)。