Cara menggunakan java untuk melaksanakan algoritma kitaran Hamiltonian graf

Cara menggunakan Java untuk melaksanakan algoritma kitaran Hamiltonian untuk graf

Kitaran Hamiltonian ialah masalah pengiraan dalam teori graf, iaitu mencari laluan tertutup yang mengandungi semua bucu dalam graf tertentu. Dalam artikel ini, kami akan memperkenalkan secara terperinci cara melaksanakan algoritma kitaran Hamiltonian menggunakan bahasa pengaturcaraan Java dan memberikan contoh kod yang sepadan.

1. Perwakilan Graf
   Pertama, kita perlu menggunakan struktur data yang sesuai untuk mewakili graf. Di Java, kita boleh mewakili graf menggunakan matriks bersebelahan atau senarai terpaut bersebelahan. Di sini kita memilih untuk menggunakan matriks bersebelahan untuk mewakili graf. Tentukan kelas bernama Graf dengan sifat dan kaedah berikut:

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;
    }
}

Graph的类，包含以下属性和方法：

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]);
    }
}

2. 哈密顿回路算法
   接下来，我们将使用回溯法来实现哈密顿回路算法。定义一个名为HamiltonianCycle的类，包含以下方法：

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();
    }
}

3. 测试
   最后，我们可以使用以下代码来测试我们的实现：

rrreee

在这个测试示例中，我们创建了一个具有5个顶点的图，并添加了一些边。然后我们创建了一个HamiltonianCycle对象并调用findHamiltonianCycleAlgoritma kitaran Hamiltonan

Seterusnya, kami akan menggunakan kaedah Backtracking untuk melaksanakan algoritma kitaran Hamiltonian. Tentukan kelas yang dipanggil HamiltonianCycle dengan kaedah berikut: rrreee

Ujian

Akhir sekali, kami boleh menggunakan kod berikut untuk menguji Pelaksanaan kami:

rrreee🎜Dalam contoh ujian ini, kami mencipta graf dengan 5 bucu dan menambah beberapa tepi. Kemudian kami mencipta objek HamiltonianCycle dan memanggil kaedah findHamiltonianCycle untuk mencari dan mengeluarkan kitaran Hamiltonian. 🎜🎜Melalui langkah di atas, kami berjaya melaksanakan algoritma kitaran Hamiltonian graf menggunakan bahasa pengaturcaraan Java. Anda boleh menukar bilangan bucu dan sambungan tepi mengikut keperluan, dan kemudian jalankan kod untuk mengesahkan ketepatan dan kesan algoritma. 🎜

Atas ialah kandungan terperinci Cara menggunakan java untuk melaksanakan algoritma kitaran Hamiltonian graf. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!