用java编写输入格式：第一行是整数n和m,接下来的第2行到第m+1行是每行包含4个元素x，y，w和d来描述一条道路，其中x和y是一条长度为w的道路相连的两个编号，d是字符N.E.S.或W，表示北东南西的方向，输出格式：给出最远的一对元素之间的距离

这道题目可以通过图的最短路径算法来解决，具体步骤如下：

1. 读入输入数据，包括整数n和m以及m条道路的信息。

2. 构建图的邻接表表示，其中每个节点表示一个城市，每条边表示一条道路，边权为道路长度。

3. 使用Dijkstra算法或者Floyd算法计算出任意两个节点之间的最短路径。

4. 遍历所有的节点对，找到最远的一对元素之间的距离。

下面是一份Java代码实现：

import java.util.*;

public class Main {
    static 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();
        Map<Integer, List<int[]>> graph = new HashMap<>();

        for (int i = 0; i < m; i++) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            int w = sc.nextInt();
            char d = sc.next().charAt(0);

            int dx = 0, dy = 0;
            if (d == 'N') {
                dx = -1;
            } else if (d == 'E') {
                dy = 1;
            } else if (d == 'S') {
                dx = 1;
            } else if (d == 'W') {
                dy = -1;
            }

            int nx = x, ny = y;
            for (int j = 0; j < w; j++) {
                nx += dx;
                ny += dy;
                addEdge(graph, nx, ny);
            }
        }

        int maxDist = 0;
        int[] farthestPair = null;
        for (int i = 1; i <= n; i++) {
            int[] dist = shortestPath(graph, i, n);
            for (int j = i + 1; j <= n; j++) {
                if (dist[j] > maxDist) {
                    maxDist = dist[j];
                    farthestPair = new int[]{i, j};
                }
            }
        }

        System.out.println(maxDist);
    }

    static void addEdge(Map<Integer, List<int[]>> graph, int u, int v) {
        if (!graph.containsKey(u)) {
            graph.put(u, new ArrayList<>());
        }
        graph.get(u).add(new int[]{v, 1});
        if (!graph.containsKey(v)) {
            graph.put(v, new ArrayList<>());
        }
        graph.get(v).add(new int[]{u, 1});
    }

    static int[] shortestPath(Map<Integer, List<int[]>> graph, int start, int n) {
        int[] dist = new int[n + 1];
        Arrays.fill(dist, INF);
        dist[start] = 0;

        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
        pq.offer(new int[]{start, 0});

        while (!pq.isEmpty()) {
            int[] cur = pq.poll();
            int u = cur[0];
            int d = cur[1];

            if (d > dist[u]) {
                continue;
            }

            if (graph.containsKey(u)) {
                for (int[] edge : graph.get(u)) {
                    int v = edge[0];
                    int w = edge[1];
                    if (dist[v] > dist[u] + w) {
                        dist[v] = dist[u] + w;
                        pq.offer(new int[]{v, dist[v]});
                    }
                }
            }
        }

        return dist;
    }
}

上述代码中使用了Dijkstra算法求解最短路径。在构建图的邻接表表示时，对于每一条道路，可以使用两个节点相邻的方法来添加边，例如对于道路(x,y,w,d)，可以从节点x开始，不断向d指定的方向走w步，直到到达节点y，这样就可以把道路转换成节点之间的边。最后，遍历所有的节点对，找到最远的一对元素之间的距离即可。