How to use java to implement the Hamiltonian cycle algorithm of graphs-Java Tutorial-php.cn

How to use java to implement the Hamiltonian cycle algorithm of graphs

王林

Release： 2023-09-21 09:03:32

Original

1338 people have browsed it

How to use java to implement the Hamiltonian cycle algorithm of graphs

How to use Java to implement the Hamiltonian cycle algorithm of a graph

A Hamiltonian cycle is a computational problem in graph theory, that is, finding a path in a given graph A closed path containing all vertices. In this article, we will introduce in detail how to implement the Hamiltonian cycle algorithm using the Java programming language and provide corresponding code examples.

Graph representation
First, we need to use an appropriate data structure to represent the graph. In Java, we can represent graphs using adjacency matrices or adjacency linked lists. Here we choose to use an adjacency matrix to represent the graph. Define a class named Graph, containing the following properties and methods:

class Graph {
    private int[][] adjacencyMatrix;
    private int numVertices;

    public Graph(int numVertices) {
        this.numVertices = numVertices;
        adjacencyMatrix = new int[numVertices][numVertices];
    }

    public void addEdge(int start, int end) {
        adjacencyMatrix[start][end] = 1;
        adjacencyMatrix[end][start] = 1;
    }

    public boolean isConnected(int start, int end) {
        return adjacencyMatrix[start][end] == 1;
    }
}

Copy after login

Hamiltonian cycle algorithm
Next, we will use the backtracking method to implement Hamiltonian cycle algorithm. Define a class called HamiltonianCycle with the following methods:

class HamiltonianCycle {
    private Graph graph;
    private int numVertices;
    private int[] path;

    public HamiltonianCycle(Graph graph) {
        this.graph = graph;
        this.numVertices = graph.getNumVertices();
        this.path = new int[numVertices];
        // 将路径初始化为-1，表示顶点还未被遍历
        for (int i = 0; i < numVertices; i++) {
            path[i] = -1;
        }
    }

    public void findHamiltonianCycle() {
        path[0] = 0; // 从顶点0开始
        if (findFeasibleSolution(1)) {
            printSolution();
        } else {
            System.out.println("No solution exists.");
        }
    }

    private boolean findFeasibleSolution(int position) {
        if (position == numVertices) {
            int start = path[position - 1];
            int end = path[0];
            if (graph.isConnected(start, end)) {
                return true;
            } else {
                return false;
            }
        }

        for (int vertex = 1; vertex < numVertices; vertex++) {
            if (isFeasible(vertex, position)) {
                path[position] = vertex;
                if (findFeasibleSolution(position + 1)) {
                    return true;
                }
                // 回溯
                path[position] = -1;
            }
        }
        return false;
    }

    private boolean isFeasible(int vertex, int actualPosition) {
        // 两个相邻顶点之间必须是连通的
        if (!graph.isConnected(path[actualPosition - 1], vertex)) {
            return false;
        }
        // 该顶点是否已经在路径中
        for (int i = 0; i < actualPosition; i++) {
            if (path[i] == vertex) {
                return false;
            }
        }
        return true;
    }

    private void printSolution() {
        System.out.println("Hamiltonian Cycle exists:");
        for (int i = 0; i < numVertices; i++) {
            System.out.print(path[i] + " ");
        }
        System.out.println(path[0]);
    }
}

Copy after login

Testing
Finally, we can test our implementation using the following code:

public class Main {
    public static void main(String[] args) {
        Graph graph = new Graph(5);
        graph.addEdge(0, 1);
        graph.addEdge(0, 3);
        graph.addEdge(1, 2);
        graph.addEdge(1, 3);
        graph.addEdge(1, 4);
        graph.addEdge(2, 4);
        graph.addEdge(3, 4);

        HamiltonianCycle hamiltonianCycle = new HamiltonianCycle(graph);
        hamiltonianCycle.findHamiltonianCycle();
    }
}

Copy after login

In this test example, we create a graph with 5 vertices and add some edges. Then we create a HamiltonianCycle object and call the findHamiltonianCycle method to find and output the Hamiltonian cycle.

Through the above steps, we successfully implemented the Hamiltonian cycle algorithm of the graph using the Java programming language. You can change the number of vertices and edge connections as needed, and then run the code to verify the correctness and effect of the algorithm.

The above is the detailed content of How to use java to implement the Hamiltonian cycle algorithm of graphs. For more information, please follow other related articles on the PHP Chinese website!