Java MST-将哈密顿路径还原为循环

我有这段代码来为给定的图找到最小生成树。我需要还原这个算法，得到一个哈密顿循环，而不是哈密顿路径。你能帮我把这个代码还原成哈密顿循环吗？我需要它来解决旅行推销员的问题。我试图删除并更改负责丢弃下一个_边的代码片段，如果边导致循环并从顶点1-2添加其他边，但当我删除它时，程序返回arrayIndexOutOfBoundsException，当我将if（x！=y）更改为if（x==y）或删除此条件时，输出图被0重新填充。 我是个编程新手，我自己解决不了这个问题

代码如下：

import java.util.*;
import java.lang.*;
import java.io.*;

class Graph {
    // A class to represent a graph edge
    class Edge implements Comparable<Edge> {
        int src, dest, weight;


        // Comparator function used for sorting edges
        // based on their weight
        public int compareTo(Edge compareEdge) {
            return this.weight - compareEdge.weight;
        }
    };

// A class to represent a subset for union-find
    class subset {
        int parent, rank;
    };

    int V, E;    // V-> no. of vertices & E->no.of edges
    Edge edge[]; // collection of all edges

// Creates a graph with V vertices and E edges
    Graph(int v, int e) {
        V = v;
        E = e;
        edge = new Edge[E];

        for (int i = 0; i < e; ++i) {
            edge[i] = new Edge();
        }
    }

// A utility function to find set of an element i
// (uses path compression technique)
    int find(subset subsets[], int i) {
        // find root and make root as parent of i (path compression)
        if (subsets[i].parent != i) {
            subsets[i].parent = find(subsets, subsets[i].parent);
        }

        return subsets[i].parent;
    }

// A function that does union of two sets of x and y
// (uses union by rank)
    void Union(subset subsets[], int x, int y) {
        int xroot = find(subsets, x);
        int yroot = find(subsets, y);

        // Attach smaller rank tree under root of high rank tree
        // (Union by Rank)
        if (subsets[xroot].rank < subsets[yroot].rank) {
            subsets[xroot].parent = yroot;

        } else if (subsets[xroot].rank > subsets[yroot].rank) {
            subsets[yroot].parent = xroot;
        }

        // If ranks are same, then make one as root and increment
        // its rank by one
        else {
            subsets[yroot].parent = xroot;
            subsets[xroot].rank++;
        }
    }

// The main function to construct MST using Kruskal's algorithm
    void KruskalMST() {
        Edge result[] = new Edge[V];  // Tnis will store the resultant MST
        int e = 0;  // An index variable, used for result[]
        int i = 0;  // An index variable, used for sorted edges

        for (i = 0; i < V; ++i) {
            result[i] = new Edge();
        }

        // Step 1:  Sort all the edges in non-decreasing order of their
        // weight.  If we are not allowed to change the given graph, we
        // can create a copy of array of edges
        Arrays.sort(edge);

        // Allocate memory for creating V ssubsets
        subset subsets[] = new subset[V];

        for (i = 0; i < V; ++i) {
            subsets[i] = new subset();
        }

        // Create V subsets with single elements
        for (int v = 0; v < V; ++v) {
            subsets[v].parent = v;
            subsets[v].rank = 0;
        }

        i = 0;  // Index used to pick next edge

        // Number of edges to be taken is equal to V-1
        while (e < V - 1) {
            // Step 2: Pick the smallest edge. And increment
            // the index for next iteration
            Edge next_edge = new Edge();
            next_edge = edge[i++];

            int x = find(subsets, next_edge.src);
            int y = find(subsets, next_edge.dest);

            // If including this edge does't cause cycle,
            // include it in result and increment the index
            // of result for next edge
            if (x != y) {
                result[e++] = next_edge;
                Union(subsets, x, y);
            }

            // Else discard the next_edge
        }

        // print the contents of result[] to display
        // the built MST
        System.out.println("Following are the edges in " +
                           "the constructed MST");

        for (i = 0; i < e; ++i)
            System.out.println(result[i].src + " -- " +
                               result[i].dest + " == " + result[i].weight);
    }

// Driver Program
    public static void main (String[] args) {

        /* Let us create following weighted graph
                 10
            0--------1
            |  \     |
           6|   5\   |15
            |      \ |
            2--------3
                4       */
        int V = 4;  // Number of vertices in graph
        int E = 5;  // Number of edges in graph
        Graph graph = new Graph(V, E);

        // add edge 0-1
        graph.edge[0].src = 0;
        graph.edge[0].dest = 1;
        graph.edge[0].weight = 10;

        // add edge 0-2
        graph.edge[1].src = 0;
        graph.edge[1].dest = 2;
        graph.edge[1].weight = 6;

        // add edge 0-3
        graph.edge[2].src = 0;
        graph.edge[2].dest = 3;
        graph.edge[2].weight = 5;

        // add edge 1-3
        graph.edge[3].src = 1;
        graph.edge[3].dest = 3;
        graph.edge[3].weight = 15;

        // add edge 2-3
        graph.edge[4].src = 2;
        graph.edge[4].dest = 3;
        graph.edge[4].weight = 4;

        graph.KruskalMST();
    }
}

import java.util.*；
导入java.lang.*；
导入java.io.*；
类图{
//表示图边的类
类Edge实现了可比较的{
内部src、目的地、重量；
//用于边缘排序的比较器函数
//根据他们的体重
公共整数比较（边比较页）{
返回this.weight-compareEdge.weight；
}
};
//表示联合查找的子集的类
类子集{
int父级，秩；
};
int V，E；//V->顶点数&E->边数
边[]；//所有边的集合
//创建具有V顶点和E边的图形
图（int v，int e）{
V=V；
E=E；
边=新边[E]；
对于（int i=0；i子集[yroot].rank）{
子集[yroot]。父项=xroot；
}
//如果秩相同，则将一个作为根并递增
//它排名靠前
否则{
子集[yroot]。父项=xroot；
子集[xroot].rank++；
}
}
//使用Kruskal算法构造MST的主要函数
void KruskalMST（）{
边缘结果[]=新边缘[V]；//Tnis将存储结果MST
int e=0；//一个索引变量，用于结果[]
int i=0；//一个索引变量，用于排序的边
对于（i=0；i

我不确定我是否理解您的方法。在绝大多数情况下，图的MST不是哈密顿路径。即使产生一个循环，增加一个最低成本优势也意味着结果不是MST，也很可能不是哈密顿路径。你能解释一下吗？我不太明白