📜  哈密顿周期|回溯6

📅  最后修改于: 2021-04-25 00:02:49             🧑  作者: Mango

无向图中的汉密尔顿路径是一条只访问每个顶点一次的路径。哈密顿循环(或哈密顿回路)是哈密顿路径,因此从哈密顿路径的最后一个顶点到第一个顶点有一条边(在图中)。确定给定图是否包含哈密顿循环。如果包含,则打印路径。以下是所需函数的输入和输出。

输入:
二维数组graph [V] [V],其中V是图形中的顶点数,而graph [V] [V]是图形的邻接矩阵表示。如果存在从i到j的直接边,则值graph [i] [j]为1,否则graph [i] [j]为0。

输出:
包含哈密顿路径的数组路径[V]。 path [i]应该表示哈密顿路径中的第i个顶点。如果图中没有汉密尔顿循环,则代码也应返回false。

例如,下图中的哈密顿循环为{0,1,2,4,4,3,0}。

(0)--(1)--(2)
 |   / \   |
 |  /   \  | 
 | /     \ |
(3)-------(4)

下图不包含任何哈密顿循环。

(0)--(1)--(2)
 |   / \   |
 |  /   \  | 
 | /     \ |
(3)      (4) 

天真的算法
生成所有可能的顶点配置,并打印满足给定约束的配置。会有n! (n个阶乘)配置。

while there are untried conflagrations
{
   generate the next configuration
   if ( there are edges between two consecutive vertices of this
      configuration and there is an edge from the last vertex to 
      the first ).
   {
      print this configuration;
      break;
   }
}

回溯算法
创建一个空路径数组,并向其添加顶点0。从顶点开始添加其他顶点。1.添加顶点之前,检查它是否与先前添加的顶点相邻并且尚未添加。如果找到这样的顶点,则将其添加为解决方案的一部分。如果找不到顶点,则返回false。

回溯解决方案的实施
以下是回溯解决方案的实现。

C++
/* C++ program for solution of Hamiltonian 
Cycle problem using backtracking */
#include 
using namespace std;
  
// Number of vertices in the graph 
#define V 5 
  
void printSolution(int path[]); 
  
/* A utility function to check if 
the vertex v can be added at index 'pos' 
in the Hamiltonian Cycle constructed 
so far (stored in 'path[]') */
bool isSafe(int v, bool graph[V][V], 
            int path[], int pos) 
{ 
    /* Check if this vertex is an adjacent 
    vertex of the previously added vertex. */
    if (graph [path[pos - 1]][ v ] == 0) 
        return false; 
  
    /* Check if the vertex has already been included. 
    This step can be optimized by creating
    an array of size V */
    for (int i = 0; i < pos; i++) 
        if (path[i] == v) 
            return false; 
  
    return true; 
} 
  
/* A recursive utility function 
to solve hamiltonian cycle problem */
bool hamCycleUtil(bool graph[V][V], 
                  int path[], int pos) 
{ 
    /* base case: If all vertices are 
    included in Hamiltonian Cycle */
    if (pos == V) 
    { 
        // And if there is an edge from the 
        // last included vertex to the first vertex 
        if (graph[path[pos - 1]][path[0]] == 1) 
            return true; 
        else
            return false; 
    } 
  
    // Try different vertices as a next candidate 
    // in Hamiltonian Cycle. We don't try for 0 as 
    // we included 0 as starting point in hamCycle() 
    for (int v = 1; v < V; v++) 
    { 
        /* Check if this vertex can be added 
        // to Hamiltonian Cycle */
        if (isSafe(v, graph, path, pos)) 
        { 
            path[pos] = v; 
  
            /* recur to construct rest of the path */
            if (hamCycleUtil (graph, path, pos + 1) == true) 
                return true; 
  
            /* If adding vertex v doesn't lead to a solution, 
            then remove it */
            path[pos] = -1; 
        } 
    } 
  
    /* If no vertex can be added to 
    Hamiltonian Cycle constructed so far, 
    then return false */
    return false; 
} 
  
/* This function solves the Hamiltonian Cycle problem 
using Backtracking. It mainly uses hamCycleUtil() to 
solve the problem. It returns false if there is no 
Hamiltonian Cycle possible, otherwise return true 
and prints the path. Please note that there may be 
more than one solutions, this function prints one 
of the feasible solutions. */
bool hamCycle(bool graph[V][V]) 
{ 
    int *path = new int[V]; 
    for (int i = 0; i < V; i++) 
        path[i] = -1; 
  
    /* Let us put vertex 0 as the first vertex in the path.
    If there is a Hamiltonian Cycle, then the path can be 
    started from any point of the cycle as the graph is undirected */
    path[0] = 0; 
    if (hamCycleUtil(graph, path, 1) == false ) 
    { 
        cout << "\nSolution does not exist"; 
        return false; 
    } 
  
    printSolution(path); 
    return true; 
} 
  
/* A utility function to print solution */
void printSolution(int path[]) 
{ 
    cout << "Solution Exists:"
            " Following is one Hamiltonian Cycle \n"; 
    for (int i = 0; i < V; i++) 
        cout << path[i] << " "; 
  
    // Let us print the first vertex again
    // to show the complete cycle 
    cout << path[0] << " "; 
    cout << endl;
} 
  
// Driver Code 
int main() 
{ 
    /* Let us create the following graph 
        (0)--(1)--(2) 
        | / \ | 
        | / \ | 
        | / \ | 
        (3)-------(4) */
    bool graph1[V][V] = {{0, 1, 0, 1, 0}, 
                        {1, 0, 1, 1, 1}, 
                        {0, 1, 0, 0, 1}, 
                        {1, 1, 0, 0, 1}, 
                        {0, 1, 1, 1, 0}}; 
      
    // Print the solution 
    hamCycle(graph1); 
      
    /* Let us create the following graph 
    (0)--(1)--(2) 
    | / \ | 
    | / \ | 
    | / \ | 
    (3) (4) */
    bool graph2[V][V] = {{0, 1, 0, 1, 0}, 
                         {1, 0, 1, 1, 1}, 
                         {0, 1, 0, 0, 1}, 
                         {1, 1, 0, 0, 0}, 
                         {0, 1, 1, 0, 0}}; 
  
    // Print the solution 
    hamCycle(graph2); 
  
    return 0; 
} 
  
// This is code is contributed by rathbhupendra


C
/* C program for solution of Hamiltonian Cycle problem
   using backtracking */
#include
  
// Number of vertices in the graph
#define V 5
  
void printSolution(int path[]);
  
/* A utility function to check if the vertex v can be added at
   index 'pos' in the Hamiltonian Cycle constructed so far (stored
   in 'path[]') */
bool isSafe(int v, bool graph[V][V], int path[], int pos)
{
    /* Check if this vertex is an adjacent vertex of the previously
       added vertex. */
    if (graph [ path[pos-1] ][ v ] == 0)
        return false;
  
    /* Check if the vertex has already been included.
      This step can be optimized by creating an array of size V */
    for (int i = 0; i < pos; i++)
        if (path[i] == v)
            return false;
  
    return true;
}
  
/* A recursive utility function to solve hamiltonian cycle problem */
bool hamCycleUtil(bool graph[V][V], int path[], int pos)
{
    /* base case: If all vertices are included in Hamiltonian Cycle */
    if (pos == V)
    {
        // And if there is an edge from the last included vertex to the
        // first vertex
        if ( graph[ path[pos-1] ][ path[0] ] == 1 )
           return true;
        else
          return false;
    }
  
    // Try different vertices as a next candidate in Hamiltonian Cycle.
    // We don't try for 0 as we included 0 as starting point in hamCycle()
    for (int v = 1; v < V; v++)
    {
        /* Check if this vertex can be added to Hamiltonian Cycle */
        if (isSafe(v, graph, path, pos))
        {
            path[pos] = v;
  
            /* recur to construct rest of the path */
            if (hamCycleUtil (graph, path, pos+1) == true)
                return true;
  
            /* If adding vertex v doesn't lead to a solution,
               then remove it */
            path[pos] = -1;
        }
    }
  
    /* If no vertex can be added to Hamiltonian Cycle constructed so far,
       then return false */
    return false;
}
  
/* This function solves the Hamiltonian Cycle problem using Backtracking.
  It mainly uses hamCycleUtil() to solve the problem. It returns false
  if there is no Hamiltonian Cycle possible, otherwise return true and
  prints the path. Please note that there may be more than one solutions,
  this function prints one of the feasible solutions. */
bool hamCycle(bool graph[V][V])
{
    int *path = new int[V];
    for (int i = 0; i < V; i++)
        path[i] = -1;
  
    /* Let us put vertex 0 as the first vertex in the path. If there is
       a Hamiltonian Cycle, then the path can be started from any point
       of the cycle as the graph is undirected */
    path[0] = 0;
    if ( hamCycleUtil(graph, path, 1) == false )
    {
        printf("\nSolution does not exist");
        return false;
    }
  
    printSolution(path);
    return true;
}
  
/* A utility function to print solution */
void printSolution(int path[])
{
    printf ("Solution Exists:"
            " Following is one Hamiltonian Cycle \n");
    for (int i = 0; i < V; i++)
        printf(" %d ", path[i]);
  
    // Let us print the first vertex again to show the complete cycle
    printf(" %d ", path[0]);
    printf("\n");
}
  
// driver program to test above function
int main()
{
   /* Let us create the following graph
      (0)--(1)--(2)
       |   / \   |
       |  /   \  |
       | /     \ |
      (3)-------(4)    */
   bool graph1[V][V] = {{0, 1, 0, 1, 0},
                      {1, 0, 1, 1, 1},
                      {0, 1, 0, 0, 1},
                      {1, 1, 0, 0, 1},
                      {0, 1, 1, 1, 0},
                     };
  
    // Print the solution
    hamCycle(graph1);
  
   /* Let us create the following graph
      (0)--(1)--(2)
       |   / \   |
       |  /   \  |
       | /     \ |
      (3)       (4)    */
    bool graph2[V][V] = {{0, 1, 0, 1, 0},
                      {1, 0, 1, 1, 1},
                      {0, 1, 0, 0, 1},
                      {1, 1, 0, 0, 0},
                      {0, 1, 1, 0, 0},
                     };
  
    // Print the solution
    hamCycle(graph2);
  
    return 0;
}


Java
/* Java program for solution of Hamiltonian Cycle problem
   using backtracking */
class HamiltonianCycle
{
    final int V = 5;
    int path[];
  
    /* A utility function to check if the vertex v can be
       added at index 'pos'in the Hamiltonian Cycle
       constructed so far (stored in 'path[]') */
    boolean isSafe(int v, int graph[][], int path[], int pos)
    {
        /* Check if this vertex is an adjacent vertex of
           the previously added vertex. */
        if (graph[path[pos - 1]][v] == 0)
            return false;
  
        /* Check if the vertex has already been included.
           This step can be optimized by creating an array
           of size V */
        for (int i = 0; i < pos; i++)
            if (path[i] == v)
                return false;
  
        return true;
    }
  
    /* A recursive utility function to solve hamiltonian
       cycle problem */
    boolean hamCycleUtil(int graph[][], int path[], int pos)
    {
        /* base case: If all vertices are included in
           Hamiltonian Cycle */
        if (pos == V)
        {
            // And if there is an edge from the last included
            // vertex to the first vertex
            if (graph[path[pos - 1]][path[0]] == 1)
                return true;
            else
                return false;
        }
  
        // Try different vertices as a next candidate in
        // Hamiltonian Cycle. We don't try for 0 as we
        // included 0 as starting point in hamCycle()
        for (int v = 1; v < V; v++)
        {
            /* Check if this vertex can be added to Hamiltonian
               Cycle */
            if (isSafe(v, graph, path, pos))
            {
                path[pos] = v;
  
                /* recur to construct rest of the path */
                if (hamCycleUtil(graph, path, pos + 1) == true)
                    return true;
  
                /* If adding vertex v doesn't lead to a solution,
                   then remove it */
                path[pos] = -1;
            }
        }
  
        /* If no vertex can be added to Hamiltonian Cycle
           constructed so far, then return false */
        return false;
    }
  
    /* This function solves the Hamiltonian Cycle problem using
       Backtracking. It mainly uses hamCycleUtil() to solve the
       problem. It returns false if there is no Hamiltonian Cycle
       possible, otherwise return true and prints the path.
       Please note that there may be more than one solutions,
       this function prints one of the feasible solutions. */
    int hamCycle(int graph[][])
    {
        path = new int[V];
        for (int i = 0; i < V; i++)
            path[i] = -1;
  
        /* Let us put vertex 0 as the first vertex in the path.
           If there is a Hamiltonian Cycle, then the path can be
           started from any point of the cycle as the graph is
           undirected */
        path[0] = 0;
        if (hamCycleUtil(graph, path, 1) == false)
        {
            System.out.println("\nSolution does not exist");
            return 0;
        }
  
        printSolution(path);
        return 1;
    }
  
    /* A utility function to print solution */
    void printSolution(int path[])
    {
        System.out.println("Solution Exists: Following" +
                           " is one Hamiltonian Cycle");
        for (int i = 0; i < V; i++)
            System.out.print(" " + path[i] + " ");
  
        // Let us print the first vertex again to show the
        // complete cycle
        System.out.println(" " + path[0] + " ");
    }
  
    // driver program to test above function
    public static void main(String args[])
    {
        HamiltonianCycle hamiltonian =
                                new HamiltonianCycle();
        /* Let us create the following graph
           (0)--(1)--(2)
            |   / \   |
            |  /   \  |
            | /     \ |
           (3)-------(4)    */
        int graph1[][] = {{0, 1, 0, 1, 0},
            {1, 0, 1, 1, 1},
            {0, 1, 0, 0, 1},
            {1, 1, 0, 0, 1},
            {0, 1, 1, 1, 0},
        };
  
        // Print the solution
        hamiltonian.hamCycle(graph1);
  
        /* Let us create the following graph
           (0)--(1)--(2)
            |   / \   |
            |  /   \  |
            | /     \ |
           (3)       (4)    */
        int graph2[][] = {{0, 1, 0, 1, 0},
            {1, 0, 1, 1, 1},
            {0, 1, 0, 0, 1},
            {1, 1, 0, 0, 0},
            {0, 1, 1, 0, 0},
        };
  
        // Print the solution
        hamiltonian.hamCycle(graph2);
    }
}
// This code is contributed by Abhishek Shankhadhar


Python3
# Python program for solution of 
# hamiltonian cycle problem 
  
class Graph(): 
    def __init__(self, vertices): 
        self.graph = [[0 for column in range(vertices)]
                            for row in range(vertices)] 
        self.V = vertices 
  
    ''' Check if this vertex is an adjacent vertex 
        of the previously added vertex and is not 
        included in the path earlier '''
    def isSafe(self, v, pos, path): 
        # Check if current vertex and last vertex 
        # in path are adjacent 
        if self.graph[ path[pos-1] ][v] == 0: 
            return False
  
        # Check if current vertex not already in path 
        for vertex in path: 
            if vertex == v: 
                return False
  
        return True
  
    # A recursive utility function to solve 
    # hamiltonian cycle problem 
    def hamCycleUtil(self, path, pos): 
  
        # base case: if all vertices are 
        # included in the path 
        if pos == self.V: 
            # Last vertex must be adjacent to the 
            # first vertex in path to make a cyle 
            if self.graph[ path[pos-1] ][ path[0] ] == 1: 
                return True
            else: 
                return False
  
        # Try different vertices as a next candidate 
        # in Hamiltonian Cycle. We don't try for 0 as 
        # we included 0 as starting point in hamCycle() 
        for v in range(1,self.V): 
  
            if self.isSafe(v, pos, path) == True: 
  
                path[pos] = v 
  
                if self.hamCycleUtil(path, pos+1) == True: 
                    return True
  
                # Remove current vertex if it doesn't 
                # lead to a solution 
                path[pos] = -1
  
        return False
  
    def hamCycle(self): 
        path = [-1] * self.V 
  
        ''' Let us put vertex 0 as the first vertex 
            in the path. If there is a Hamiltonian Cycle, 
            then the path can be started from any point 
            of the cycle as the graph is undirected '''
        path[0] = 0
  
        if self.hamCycleUtil(path,1) == False: 
            print ("Solution does not exist\n")
            return False
  
        self.printSolution(path) 
        return True
  
    def printSolution(self, path): 
        print ("Solution Exists: Following",
                 "is one Hamiltonian Cycle")
        for vertex in path: 
            print (vertex, end = " ")
        print (path[0], "\n")
  
# Driver Code 
  
''' Let us create the following graph 
    (0)--(1)--(2) 
    | / \ | 
    | / \ | 
    | /     \ | 
    (3)-------(4) '''
g1 = Graph(5) 
g1.graph = [ [0, 1, 0, 1, 0], [1, 0, 1, 1, 1], 
            [0, 1, 0, 0, 1,],[1, 1, 0, 0, 1], 
            [0, 1, 1, 1, 0], ] 
  
# Print the solution 
g1.hamCycle(); 
  
''' Let us create the following graph 
    (0)--(1)--(2) 
    | / \ | 
    | / \ | 
    | /     \ | 
    (3)     (4) '''
g2 = Graph(5) 
g2.graph = [ [0, 1, 0, 1, 0], [1, 0, 1, 1, 1], 
        [0, 1, 0, 0, 1,], [1, 1, 0, 0, 0], 
        [0, 1, 1, 0, 0], ] 
  
# Print the solution 
g2.hamCycle(); 
  
# This code is contributed by Divyanshu Mehta


C#
// C# program for solution of Hamiltonian 
// Cycle problem using backtracking
using System;
  
public class HamiltonianCycle
{
    readonly int V = 5;
    int []path;
  
    /* A utility function to check 
    if the vertex v can be added at 
    index 'pos'in the Hamiltonian Cycle
    constructed so far (stored in 'path[]') */
    bool isSafe(int v, int [,]graph,
                int []path, int pos)
    {
        /* Check if this vertex is 
        an adjacent vertex of the
        previously added vertex. */
        if (graph[path[pos - 1], v] == 0)
            return false;
  
        /* Check if the vertex has already 
        been included. This step can be
        optimized by creating an array
        of size V */
        for (int i = 0; i < pos; i++)
            if (path[i] == v)
                return false;
  
        return true;
    }
  
    /* A recursive utility function
    to solve hamiltonian cycle problem */
    bool hamCycleUtil(int [,]graph, int []path, int pos)
    {
        /* base case: If all vertices 
        are included in Hamiltonian Cycle */
        if (pos == V)
        {
            // And if there is an edge from the last included
            // vertex to the first vertex
            if (graph[path[pos - 1],path[0]] == 1)
                return true;
            else
                return false;
        }
  
        // Try different vertices as a next candidate in
        // Hamiltonian Cycle. We don't try for 0 as we
        // included 0 as starting point in hamCycle()
        for (int v = 1; v < V; v++)
        {
            /* Check if this vertex can be 
            added to Hamiltonian Cycle */
            if (isSafe(v, graph, path, pos))
            {
                path[pos] = v;
  
                /* recur to construct rest of the path */
                if (hamCycleUtil(graph, path, pos + 1) == true)
                    return true;
  
                /* If adding vertex v doesn't 
                lead to a solution, then remove it */
                path[pos] = -1;
            }
        }
  
        /* If no vertex can be added to Hamiltonian Cycle
        constructed so far, then return false */
        return false;
    }
  
    /* This function solves the Hamiltonian 
    Cycle problem using Backtracking. It 
    mainly uses hamCycleUtil() to solve the
    problem. It returns false if there
    is no Hamiltonian Cycle possible, 
    otherwise return true and prints the path.
    Please note that there may be more than 
    one solutions, this function prints one 
    of the feasible solutions. */
    int hamCycle(int [,]graph)
    {
        path = new int[V];
        for (int i = 0; i < V; i++)
            path[i] = -1;
  
        /* Let us put vertex 0 as the first
        vertex in the path. If there is a 
        Hamiltonian Cycle, then the path can be
        started from any point of the cycle 
        as the graph is undirected */
        path[0] = 0;
        if (hamCycleUtil(graph, path, 1) == false)
        {
            Console.WriteLine("\nSolution does not exist");
            return 0;
        }
  
        printSolution(path);
        return 1;
    }
  
    /* A utility function to print solution */
    void printSolution(int []path)
    {
        Console.WriteLine("Solution Exists: Following" +
                        " is one Hamiltonian Cycle");
        for (int i = 0; i < V; i++)
            Console.Write(" " + path[i] + " ");
  
        // Let us print the first vertex again
        //  to show the complete cycle
        Console.WriteLine(" " + path[0] + " ");
    }
  
    // Driver code
    public static void Main(String []args)
    {
        HamiltonianCycle hamiltonian =
                                new HamiltonianCycle();
        /* Let us create the following graph
        (0)--(1)--(2)
            | / \ |
            | / \ |
            | /     \ |
        (3)-------(4) */
        int [,]graph1= {{0, 1, 0, 1, 0},
            {1, 0, 1, 1, 1},
            {0, 1, 0, 0, 1},
            {1, 1, 0, 0, 1},
            {0, 1, 1, 1, 0},
        };
  
        // Print the solution
        hamiltonian.hamCycle(graph1);
  
        /* Let us create the following graph
        (0)--(1)--(2)
            | / \ |
            | / \ |
            | /     \ |
        (3)     (4) */
        int [,]graph2 = {{0, 1, 0, 1, 0},
            {1, 0, 1, 1, 1},
            {0, 1, 0, 0, 1},
            {1, 1, 0, 0, 0},
            {0, 1, 1, 0, 0},
        };
  
        // Print the solution
        hamiltonian.hamCycle(graph2);
    }
}
  
// This code contributed by Rajput-Ji


PHP


输出:

Solution Exists: Following is one Hamiltonian Cycle
 0  1  2  4  3  0

Solution does not exist

请注意,上面的代码始终打印从0开始的循环。起始点无关紧要,因为可以从任何点开始循环。如果要更改起点,则应对以上代码进行两次更改。
更改为“ path [0] = 0;”改为“ path [0] = s;” s是您的新起点。还要将hamCycleUtil()中的“ for(int v = 1; v