哈密顿路径在图G中找出一条包含所有顶点的简单路径，该路径称为哈密顿路径（1）图G是非完全有向图，且图G不一定存在哈密顿路径； ＞ （2）设计算法判断图G是否存在哈密顿路径，如果存在，输出一天哈密顿路径

不要自卑，去提升实力
互联网行业谁技术牛谁是爹
如果文章可以带给你能量，那是最好的事！请相信自己
加油o~

1、问题描述

在图G中找出一条包含所有顶点的简单路径，该路径称为哈密顿路径

2、基本要求

（1）图G是非完全有向图，且图G不一定存在哈密顿路径；
（2）设计算法判断图G是否存在哈密顿路径，如果存在，输出一天哈密顿路径即可；
（3）分析算法的时间复杂度。

3、设计思想

寻找哈密顿路径的过程是一个深度优先遍历的过程。在遍历过程中，如果有回溯，说明遍历经过的路线中存在重复访问的节点，所以，可以修改深度优先遍历算法，使其在遍历过程中取消回溯。

以下代码仅供参考
以下代码仅供参考
以下代码仅供参考

/**
 *作者：魏宝航
 *2020年11月22日,下午21:47
 */
import java.io.IOException;
import java.util.Scanner;

public class MatrixUDG {

    private char[] mVexs;       
    private int[][] mMatrix;   
    private int num;
    private int edge;
    private boolean[] visit;
    private int[] road;
    private static int count=0;
    private int m=0;

    public MatrixUDG(char[] vexs, char[][] edges) {

        num = vexs.length;
        edge = edges.length;

        visit=new boolean[num+10];
        road=new int[num+10];

        mVexs = new char[num];
        for (int i = 0; i < mVexs.length; i++)
            mVexs[i] = vexs[i];

        mMatrix = new int[num][num];
        for(int i=0;i<edge;i++){
            for(int j=0;j<edge;j++){
                if(edges[i][j]=='∞'){
                    mMatrix[i][j]=Integer.MAX_VALUE;
                }
                else{
                    mMatrix[i][j]=1;
                }
            }
        }
    }

    public void print() {
        System.out.printf("Martix Graph:\n");
        for (int i = 0; i < mVexs.length; i++) {
            for (int j = 0; j < mVexs.length; j++){
                if(mMatrix[i][j]<Integer.MAX_VALUE){
                    System.out.printf("%d ", mMatrix[i][j]);
                }else{
                    System.out.print("∞ ");
                }
            }

            System.out.printf("\n");
        }
    }

    public void DFS(int v){
        visit[v]=true;
        road[count++]=v;
        for(m=0;m<num;m++){
            if(mMatrix[v][m]==1&&visit[m]==false){
                DFS(m);
            }
        }
        if(m==num){
            visit[v]=false;
            count--;
        }
    }
    
    public void Hamilton(){
        for(int i=0;i<num;i++){
            DFS(i);
        }
        System.out.print(road[0]+1);
        for(int i=1;i<num;i++){
            System.out.print("->"+(road[i]+1));
        }
    }
    
    public static void main(String[] args) {

        char[] vexs2={'1','2','3','4'};
        char[][] edges2=new char[][]{
                {'∞','1','1','∞'},
                {'∞','∞','∞','∞'},
                {'∞','1','∞','1'},
                {'∞','1','∞','∞'},
        };
        
        MatrixUDG g=new MatrixUDG(vexs2,edges2);
        g.print();
        g.Hamilton();
    }
}