TransportationCode.java

import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.util.Queue;

public class TransportationCode extends JFrame {

    private Graph graph;
    private JComboBox<String> sourceBox;
    private JTextArea outputArea;

    public TransportationCode() {
        graph = new Graph();

        setTitle("Transportation Network Application");
        setSize(900, 600);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new BorderLayout());

        JPanel controlPanel = new JPanel();
        controlPanel.setLayout(new GridLayout(9, 1, 10, 10));

        JButton addCityBtn = new JButton("Add City");
        JButton addRoadBtn = new JButton("Add Road");
        JButton shortestPathBtn = new JButton("Minimum Route");
        JButton traversalBtn = new JButton("Traversal Order");
        JButton reachabilityBtn = new JButton("Reachability Check");
        JButton mstBtn = new JButton("Minimum Cost Network");
        JButton resetBtn = new JButton("Reset Graph");

        sourceBox = new JComboBox<>();

        controlPanel.add(addCityBtn);
        controlPanel.add(addRoadBtn);
        controlPanel.add(new JLabel("Select Source City:"));
        controlPanel.add(sourceBox);
        controlPanel.add(shortestPathBtn);
        controlPanel.add(traversalBtn);
        controlPanel.add(reachabilityBtn);
        controlPanel.add(mstBtn);
        controlPanel.add(resetBtn);

        outputArea = new JTextArea();
        outputArea.setEditable(false);
        JScrollPane scrollPane = new JScrollPane(outputArea);

        add(controlPanel, BorderLayout.WEST);
        add(scrollPane, BorderLayout.CENTER);

        addCityBtn.addActionListener(e -> addCity());
        addRoadBtn.addActionListener(e -> addRoad());
        shortestPathBtn.addActionListener(e -> showShortestPath());
        traversalBtn.addActionListener(e -> showTraversal());
        reachabilityBtn.addActionListener(e -> checkReachability());
        mstBtn.addActionListener(e -> showMST());
        resetBtn.addActionListener(e -> resetGraph());

        setVisible(true);
    }

    private void addCity() {
        String city = JOptionPane.showInputDialog(this, "Enter city name:");
        if (city != null && !city.trim().isEmpty()) {
            city = city.trim();
            graph.addCity(city);
            sourceBox.addItem(city);
            outputArea.append("City Added: " + city + "\n");
        }
    }

    private void addRoad() {
        java.util.List<String> cities = graph.getCities();

        if (cities.size() < 2) {
            JOptionPane.showMessageDialog(this, "Add at least 2 cities first.");
            return;
        }

        String from = (String) JOptionPane.showInputDialog(
                this,
                "Select From City",
                "Add Road",
                JOptionPane.PLAIN_MESSAGE,
                null,
                cities.toArray(),
                null);

        String to = (String) JOptionPane.showInputDialog(
                this,
                "Select To City",
                "Add Road",
                JOptionPane.PLAIN_MESSAGE,
                null,
                cities.toArray(),
                null);

        String distanceText = JOptionPane.showInputDialog(this, "Enter Distance:");

        try {
            int distance = Integer.parseInt(distanceText);

            if (from != null && to != null && !from.equals(to)) {
                graph.addRoad(from, to, distance);
                outputArea.append("Road Added: " + from + " -> " + to + " = " + distance + "\n");
            }
        } catch (Exception e) {
            JOptionPane.showMessageDialog(this, "Invalid Distance");
        }
    }

    private void showShortestPath() {
        String source = (String) sourceBox.getSelectedItem();
        if (source == null) return;

        Map<String, Integer> result = graph.dijkstra(source);
        outputArea.setText("Minimum Route from " + source + "\n\n");

        for (String city : result.keySet()) {
    if (result.get(city) == Integer.MAX_VALUE) {
        outputArea.append(source + " -> " + city + " = Not Reachable\n");
    } else {
        outputArea.append(source + " -> " + city + " = " + result.get(city) + "\n");
    }
}
    }

    private void showTraversal() {
        String source = (String) sourceBox.getSelectedItem();
        if (source == null) return;

        java.util.List<String> order = graph.bfs(source);
        outputArea.setText("Traversal Order (BFS):\n\n");
        outputArea.append(String.join(" -> ", order));
    }

    private void checkReachability() {
        String source = (String) sourceBox.getSelectedItem();
        if (source == null) return;

        java.util.List<String> visited = graph.bfs(source);

        if (visited.size() == graph.getCities().size()) {
            outputArea.setText("All cities are reachable from " + source);
        } else {
            outputArea.setText("Some cities are unreachable from " + source);
        }
    }

    private void showMST() {
        outputArea.setText(graph.minimumSpanningTree());
    }

    private void resetGraph() {
        graph = new Graph();
        sourceBox.removeAllItems();
        outputArea.setText("");
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new TransportationCode();
            }
        });
    }
}

class Graph {

    private Map<String, Map<String, Integer>> adj;

    public Graph() {
        adj = new HashMap<>();
    }

    public void addCity(String city) {
        adj.putIfAbsent(city, new HashMap<String, Integer>());
    }

    public void addRoad(String from, String to, int distance) {
        adj.get(from).put(to, distance);
        adj.get(to).put(from, distance);
    }

    public java.util.List<String> getCities() {
        return new ArrayList<String>(adj.keySet());
    }

    public Map<String, Integer> dijkstra(String source) {
        Map<String, Integer> dist = new HashMap<String, Integer>();

        for (String city : adj.keySet()) {
            dist.put(city, Integer.MAX_VALUE);
        }

        dist.put(source, 0);

        PriorityQueue<String> pq = new PriorityQueue<String>(
                Comparator.comparingInt(dist::get)
        );

        pq.add(source);

        while (!pq.isEmpty()) {
            String current = pq.poll();

            for (String neighbor : adj.get(current).keySet()) {
                int newDistance = dist.get(current) + adj.get(current).get(neighbor);

                if (newDistance < dist.get(neighbor)) {
                    dist.put(neighbor, newDistance);
                    pq.add(neighbor);
                }
            }
        }

        return dist;
    }

    public java.util.List<String> bfs(String source) {
        java.util.List<String> order = new ArrayList<String>();
        Set<String> visited = new HashSet<String>();
        Queue<String> queue = new LinkedList<String>();

        queue.add(source);
        visited.add(source);

        while (!queue.isEmpty()) {
            String current = queue.poll();
            order.add(current);

            for (String neighbor : adj.get(current).keySet()) {
                if (!visited.contains(neighbor)) {
                    visited.add(neighbor);
                    queue.add(neighbor);
                }
            }
        }

        return order;
    }

    public String minimumSpanningTree() {
        if (adj.isEmpty()) {
            return "Graph is Empty";
        }

        String start = getCities().get(0);
        Set<String> visited = new HashSet<String>();
        visited.add(start);

        StringBuilder result = new StringBuilder();
        result.append("Minimum Cost Network (Prim's Algorithm)\n\n");

        int totalCost = 0;

        while (visited.size() < adj.size()) {
            String minFrom = "";
            String minTo = "";
            int minCost = Integer.MAX_VALUE;

            for (String from : visited) {
                for (String to : adj.get(from).keySet()) {
                    int cost = adj.get(from).get(to);

                    if (!visited.contains(to) && cost < minCost) {
                        minCost = cost;
                        minFrom = from;
                        minTo = to;
                    }
                }
            }

            if (minTo.equals("")) {
                break;
            }

            visited.add(minTo);
            totalCost += minCost;

            result.append(minFrom)
                    .append(" - ")
                    .append(minTo)
                    .append(" = ")
                    .append(minCost)
                    .append("\n");
        }

        result.append("\nTotal Cost = ").append(totalCost);
        return result.toString();
    }
}