(1) 东门 (2) 一教学楼 (3) 电子信息楼 (4) 图书馆 (5) 二教学楼 (6) 一食堂 (7) 土木楼 (8) 音乐厅 (9) 四教学楼 (10) 三教学楼 (11) 生命科学楼 (12) 东园学生公寓 (13) 体艺馆 (14) 东园体育场 (15) 礼堂 (16) 逸夫楼 (17) 红楼 (18) 林大路桥 (19) 三食堂 (20) 外语楼 (21) 八教学楼 (22) 七教学楼 (23) 六教学楼 (24) 九教学楼 (25) 国际楼 (26) 西园体育场 (27) 四食堂 (28) 后勤综合楼 (29) 五教学楼 (30) 游泳馆 (31) 教师公寓 (32) 研究生院 (33) 上林国际 (34) 学生公寓 （35）西门 1←→3:200 1←→2:300 1←→4:450 1←→11:300 2←→6:500 2←→4:100 3←→5:400 3←→7:100 3←→11:100 4←→11:50 6←→12:100 7←→8:50 8←→15:50 8←→9:100 9←→10:100 10←→11:100 11←→13:200 12←→14:300 12←→18:100 13←→14:50 14←→18:200 15←→16:50 16←→17:100 18←→19:400 18←→20:300 18←→23:400 19←→20:100 19←→26:300 20←→21:100 21←→22:50 21←→24:50 21←→25:100 22←→23:200 24←→28:400 25←→27:200 25←→28:300 26←→27:300 26←→30:100 27←→31:200 28←→29:200 28←→33:100 29←→35:300 30←→31:200 31←→32:100 32←→34:200 33←→34:100 34←→35:200 以此校园地图为例用java求解中国邮递员问题 以图形化界面输出结果

好的，我需要先对校园地图进行数据处理，将节点和边的信息转化为程序可处理的格式，然后再使用图论算法求解中国邮递员问题。最后，将结果输出在图形化界面上。

以下是样例代码，仅供参考：

import java.util.*;

public class CampusMap {
    // 存储节点和边的信息
    private static final int[][] GRAPH = {
        {1, 3, 200}, {1, 2, 300}, {1, 4, 450}, {1, 11, 300},
        {2, 6, 500}, {2, 4, 100},
        {3, 5, 400}, {3, 7, 100}, {3, 11, 100},
        {4, 11, 50},
        {6, 12, 100},
        {7, 8, 50},
        {8, 15, 50}, {8, 9, 100},
        {9, 10, 100},
        {10, 11, 100},
        {11, 13, 200},
        {12, 14, 300}, {12, 18, 100},
        {13, 14, 50},
        {14, 18, 200},
        {15, 16, 50},
        {16, 17, 100},
        {18, 19, 400}, {18, 20, 300}, {18, 23, 400},
        {19, 20, 100}, {19, 26, 300},
        {20, 21, 100},
        {21, 22, 50}, {21, 24, 50}, {21, 25, 100},
        {22, 23, 200},
        {24, 28, 400},
        {25, 27, 200}, {25, 28, 300},
        {26, 27, 300}, {26, 30, 100},
        {27, 31, 200},
        {28, 29, 200}, {28, 33, 100},
        {29, 35, 300},
        {30, 31, 200},
        {31, 32, 100},
        {32, 34, 200},
        {33, 34, 100},
        {34, 35, 200}
    };

    private static final int NODES_COUNT = 35;
    private static final int[][] DIST = new int[NODES_COUNT][NODES_COUNT];
    private static final int[][] NEXT = new int[NODES_COUNT][NODES_COUNT];

    // 初始化距离矩阵和下一节点矩阵
    static {
        for (int i = 0; i < NODES_COUNT; i++) {
            Arrays.fill(DIST[i], Integer.MAX_VALUE);
            Arrays.fill(NEXT[i], -1);
            DIST[i][i] = 0;
        }

        for (int[] edge : GRAPH) {
            int u = edge[0] - 1, v = edge[1] - 1, w = edge[2];
            DIST[u][v] = DIST[v][u] = w;
            NEXT[u][v] = v;
            NEXT[v][u] = u;
        }
    }

    // Floyd算法求解最短路径
    private static void floyd() {
        for (int k = 0; k < NODES_COUNT; k++) {
            for (int i = 0; i < NODES_COUNT; i++) {
                for (int j = 0; j < NODES_COUNT; j++) {
                    if (DIST[i][j] > DIST[i][k] + DIST[k][j]) {
                        DIST[i][j] = DIST[i][k] + DIST[k][j];
                        NEXT[i][j] = NEXT[i][k];
                    }
                }
            }
        }
    }

    // 获取两点之间的路径
    private static List<Integer> getPath(int u, int v) {
        List<Integer> path = new ArrayList<>();
        while (u != v) {
            path.add(u);
            u = NEXT[u][v];
        }
        path.add(v);
        return path;
    }

    public static void main(String[] args) {
        floyd();

        // 获取所有节点间的最短路径
        List<List<Integer>> paths = new ArrayList<>();
        for (int i = 0; i < NODES_COUNT; i++) {
            for (int j = i + 1; j < NODES_COUNT; j++) {
                if (DIST[i][j] != Integer.MAX_VALUE) {
                    paths.add(getPath(i, j));
                }
            }
        }

        // 对路径进行排序
        paths.sort(Comparator.comparingInt(List::size));

        // 求解中国邮递员问题
        List<Integer> tour = new ArrayList<>();
        tour.add(paths.get(0).get(0));
        tour.add(paths.get(0).get(1));
        paths.remove(0);
        while (!paths.isEmpty()) {
            int last = tour.get(tour.size() - 1);
            int minDist = Integer.MAX_VALUE;
            int index = -1;
            for (int i = 0; i < paths.size(); i++) {
                int u = paths.get(i).get(0), v = paths.get(i).get(paths.get(i).size() - 1);
                int dist = DIST[last][u] + DIST[u][v] + DIST[v][0];
                if (dist < minDist) {
                    minDist = dist;
                    index = i;
                }
            }
            List<Integer> path = paths.remove(index);
            if (path.get(0) == last) {
                path.remove(0);
            } else {
                Collections.reverse(path);
            }
            tour.addAll(path);
        }

        // 输出结果
        System.out.println("最优路径：");
        for (int i = 0; i < tour.size(); i++) {
            System.out.print(tour.get(i) + 1);
            if (i != tour.size() - 1) {
                System.out.print(" -> ");
            }
        }
    }
}

此代码使用了 Floyd 算法求解最短路径，再对所有节点间的最短路径进行排序，最后使用贪心算法求解中国邮递员问题，得到最优路径。最后将结果输出在控制台上。

为了实现图形化界面的输出，需要使用 Java GUI 框架，例如 JavaFX 或 Swing。可以将最优路径转化为一系列线段，然后在画布上绘制这些线段，从而展示最优路径。具体实现方式可以参考 JavaFX 或 Swing 的相关文档和教程。