Beautiful Path Code in Java

A beautiful path in graph theory refers to a path in a weighted graph that meets specific aesthetic criteria, such as minimal cost, minimal distance, or adherence to certain constraints like color or type of edges. Finding a beautiful path can be a common problem in competitive programming, routing algorithms, and network design.

In this section, we will explore the concept of finding a beautiful path in a graph using Java.

Graph Representation
Dijkstra's Algorithm for the Shortest Path

1. Graph Representation

To represent a graph in Java, we typically use adjacency lists or adjacency matrices. For the sake of efficiency, especially with sparse graphs, we will use an adjacency list.

Graph.java

import java.util.*;
class Graph {
    private int vertices;
    private LinkedList<Edge>[] adjacencyList;
    class Edge {
        int target;
        int weight;
        Edge(int target, int weight) {
            this.target = target;
            this.weight = weight;
        }
    }
    Graph(int vertices) {
        this.vertices = vertices;
        adjacencyList = new LinkedList[vertices];
        for (int i = 0; i < vertices; i++) {
            adjacencyList[i] = new LinkedList<>();
        }
    }
    void addEdge(int source, int target, int weight) {
        adjacencyList[source].add(new Edge(target, weight));
        adjacencyList[target].add(new Edge(source, weight)); // For undirected graph
    }
}

2. Dijkstra's Algorithm for the Shortest Path

Dijkstra's algorithm is a well-known algorithm for finding the shortest paths from a source vertex to all other vertices in a graph with non-negative weights.

Dijkstra.java

class Dijkstra {
    static class Node implements Comparable<Node> {
        int vertex;
        int distance;
        Node(int vertex, int distance) {
            this.vertex = vertex;
            this.distance = distance;
        }
        @Override
        public int compareTo(Node other) {
            return Integer.compare(this.distance, other.distance);
        }
    }
    int[] dijkstra(Graph graph, int source) {
        int V = graph.adjacencyList.length;
        int[] dist = new int[V];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[source] = 0;
        PriorityQueue<Node> pq = new PriorityQueue<>();
        pq.add(new Node(source, 0));
        while (!pq.isEmpty()) {
            Node node = pq.poll();
            int u = node.vertex;
            for (Graph.Edge edge : graph.adjacencyList[u]) {
                int v = edge.target;
                int weight = edge.weight;
                if (dist[u] + weight < dist[v]) {
                    dist[v] = dist[u] + weight;
                    pq.add(new Node(v, dist[v]));
                }
            }
        }
        return dist;
    }
}

3. Complete Java Code Example

Combining everything, here's a complete Java program to find the shortest beautiful path in a graph.

BeautifulPathDemo.java

import java.util.*;
class Graph {
    private int vertices;
    private LinkedList<Edge>[] adjacencyList;
    class Edge {
        int target;
        int weight;
        Edge(int target, int weight) {
            this.target = target;
            this.weight = weight;
        }
    }
    Graph(int vertices) {
        this.vertices = vertices;
        adjacencyList = new LinkedList[vertices];
        for (int i = 0; i < vertices; i++) {
            adjacencyList[i] = new LinkedList<>();
        }
    }
    void addEdge(int source, int target, int weight) {
        adjacencyList[source].add(new Edge(target, weight));
        adjacencyList[target].add(new Edge(source, weight)); // For undirected graph
    }
    LinkedList<Edge>[] getAdjacencyList() {
        return adjacencyList;
    }
}
class BeautifulPath {
    static class Node implements Comparable<Node> {
        int vertex;
        int distance;
        Node(int vertex, int distance) {
            this.vertex = vertex;
            this.distance = distance;
        }
        @Override
        public int compareTo(Node other) {
            return Integer.compare(this.distance, other.distance);
        }
    }
    int[] beautifulPath(Graph graph, int source, int maxWeight) {
        int V = graph.getAdjacencyList().length;
        int[] dist = new int[V];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[source] = 0;
        PriorityQueue<Node> pq = new PriorityQueue<>();
        pq.add(new Node(source, 0));
        while (!pq.isEmpty()) {
            Node node = pq.poll();
            int u = node.vertex;
            for (Graph.Edge edge : graph.getAdjacencyList()[u]) {
                int v = edge.target;
                int weight = edge.weight;
                if (weight <= maxWeight && dist[u] + weight < dist[v]) {
                    dist[v] = dist[u] + weight;
                    pq.add(new Node(v, dist[v]));
                }
            }
        }
        return dist;
    }
}
public class BeautifulPathDemo {
    public static void main(String[] args) {
        Graph graph = new Graph(6);
        graph.addEdge(0, 1, 4);
        graph.addEdge(0, 2, 3);
        graph.addEdge(1, 2, 1);
        graph.addEdge(1, 3, 2);
        graph.addEdge(2, 3, 4);
        graph.addEdge(3, 4, 2);
        graph.addEdge(4, 5, 3);
        BeautifulPath bp = new BeautifulPath();
        int[] distances = bp.beautifulPath(graph, 0, 3);
        System.out.println("Distances from source 0:");
        for (int i = 0; i < distances.length; i++) {
            System.out.println("Vertex " + i + " -> " + distances[i]);
        }
    }
}

Output:

 
Distances from source 0:
Vertex 0 -> 0
Vertex 1 -> 4
Vertex 2 -> 3
Vertex 3 -> 6
Vertex 4 -> 8
Vertex 5 -> 11

Conclusion

In this section, we have explored the concept of finding a beautiful path in a graph using Java. We started with graph representation, followed by Dijkstra's algorithm for finding the shortest path. Finally, we presented a complete Java example to demonstrate the implementation.

Next TopicBoolean-evaluation-in-java

← prev next →