Hamiltonian Path ( Using Dynamic Programming )
Last Updated :
18 Jan, 2023
Given an adjacency matrix adj[][] of an undirected graph consisting of N vertices, the task is to find whether the graph contains a Hamiltonian Path or not. If found to be true, then print “Yes”. Otherwise, print “No”.
A Hamiltonian path is defined as the path in a directed or undirected graph which visits each and every vertex of the graph exactly once.
Examples:
Input: adj[][] = {{0, 1, 1, 1, 0}, {1, 0, 1, 0, 1}, {1, 1, 0, 1, 1}, {1, 0, 1, 0, 0}}
Output: Yes
Explanation:
There exists a Hamiltonian Path for the given graph as shown in the image below:
Input: adj[][] = {{0, 1, 0, 0}, {1, 0, 1, 1}, {0, 1, 0, 0}, {0, 1, 0, 0}}
Output: No
Naive Approach: The simplest approach to solve the given problem is to generate all the possible permutations of N vertices. For each permutation, check if it is a valid Hamiltonian path by checking if there is an edge between adjacent vertices or not. If found to be true, then print “Yes”. Otherwise, print “No”.
Time Complexity: O(N * N!)
Auxiliary Space: O(1)
Efficient Approach: The above approach can be optimized by using Dynamic Programming and Bit Masking which is based on the following observations:
- The idea is such that for every subset S of vertices, check whether there is a hamiltonian path in the subset S that ends at vertex v where v € S.
- If v has a neighbor u, where u € S – {v}, therefore, there exists a Hamiltonian path that ends at vertex u.
- The problem can be solved by generalizing the subset of vertices and the ending vertex of the Hamiltonian path.
Follow the steps below to solve the problem:
- Initialize a boolean matrix dp[][] in dimension N*2N where dp[j ][i] represents whether there exists a path in the subset or not represented by the mask i that visits each and every vertex in i once and ends at vertex j.
- For the base case, update dp[i][1 << i] = true, for i in range [0, N – 1]
- Iterate over the range [1, 2N – 1] using the variable i and perform the following steps:
- All the vertices with bits set in mask i, are included in the subset.
- Iterate over the range [1, N] using the variable j that will represent the end vertex of the hamiltonian path of current subset mask i and perform the following steps:
- Iterate over the range using the variable i and if the value of dp[i][2N – 1] is true, then there exists a hamiltonian path ending at vertex i. Therefore, print “Yes”. Otherwise, print “No”.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
const int N = 5;
bool Hamiltonian_path(
vector<vector< int > >& adj, int N)
{
int dp[N][(1 << N)];
memset (dp, 0, sizeof dp);
for ( int i = 0; i < N; i++)
dp[i][(1 << i)] = true ;
for ( int i = 0; i < (1 << N); i++) {
for ( int j = 0; j < N; j++) {
if (i & (1 << j)) {
for ( int k = 0; k < N; k++) {
if (i & (1 << k)
&& adj[k][j]
&& j != k
&& dp[k][i ^ (1 << j)]) {
dp[j][i] = true ;
break ;
}
}
}
}
}
for ( int i = 0; i < N; i++) {
if (dp[i][(1 << N) - 1])
return true ;
}
return false ;
}
int main()
{
vector<vector< int > > adj = { { 0, 1, 1, 1, 0 },
{ 1, 0, 1, 0, 1 },
{ 1, 1, 0, 1, 1 },
{ 1, 0, 1, 0, 0 } };
int N = adj.size();
if (Hamiltonian_path(adj, N))
cout << "YES" ;
else
cout << "NO" ;
return 0;
}
|
Java
import java.io.*;
import java.lang.*;
import java.util.*;
class GFG{
static boolean Hamiltonian_path( int adj[][], int N)
{
boolean dp[][] = new boolean [N][( 1 << N)];
for ( int i = 0 ; i < N; i++)
dp[i][( 1 << i)] = true ;
for ( int i = 0 ; i < ( 1 << N); i++)
{
for ( int j = 0 ; j < N; j++)
{
if ((i & ( 1 << j)) != 0 )
{
for ( int k = 0 ; k < N; k++)
{
if ((i & ( 1 << k)) != 0 &&
adj[k][j] == 1 && j != k &&
dp[k][i ^ ( 1 << j)])
{
dp[j][i] = true ;
break ;
}
}
}
}
}
for ( int i = 0 ; i < N; i++)
{
if (dp[i][( 1 << N) - 1 ])
return true ;
}
return false ;
}
public static void main(String[] args)
{
int adj[][] = { { 0 , 1 , 1 , 1 , 0 },
{ 1 , 0 , 1 , 0 , 1 },
{ 1 , 1 , 0 , 1 , 1 },
{ 1 , 0 , 1 , 0 , 0 } };
int N = adj.length;
if (Hamiltonian_path(adj, N))
System.out.println( "YES" );
else
System.out.println( "NO" );
}
}
|
Python3
def Hamiltonian_path(adj, N):
dp = [[ False for i in range ( 1 << N)]
for j in range (N)]
for i in range (N):
dp[i][ 1 << i] = True
for i in range ( 1 << N):
for j in range (N):
if ((i & ( 1 << j)) ! = 0 ):
for k in range (N):
if ((i & ( 1 << k)) ! = 0 and
adj[k][j] = = 1 and
j ! = k and
dp[k][i ^ ( 1 << j)]):
dp[j][i] = True
break
for i in range (N):
if (dp[i][( 1 << N) - 1 ]):
return True
return False
adj = [ [ 0 , 1 , 1 , 1 , 0 ] ,
[ 1 , 0 , 1 , 0 , 1 ],
[ 1 , 1 , 0 , 1 , 1 ],
[ 1 , 0 , 1 , 0 , 0 ] ]
N = len (adj)
if (Hamiltonian_path(adj, N)):
print ( "YES" )
else :
print ( "NO" )
|
C#
using System;
class GFG{
static bool Hamiltonian_path( int [,] adj, int N)
{
bool [,] dp = new bool [N, (1 << N)];
for ( int i = 0; i < N; i++)
dp[i, (1 << i)] = true ;
for ( int i = 0; i < (1 << N); i++)
{
for ( int j = 0; j < N; j++)
{
if ((i & (1 << j)) != 0)
{
for ( int k = 0; k < N; k++)
{
if ((i & (1 << k)) != 0 &&
adj[k, j] == 1 && j != k &&
dp[k, i ^ (1 << j)])
{
dp[j, i] = true ;
break ;
}
}
}
}
}
for ( int i = 0; i < N; i++)
{
if (dp[i, (1 << N) - 1])
return true ;
}
return false ;
}
public static void Main(String[] args)
{
int [,] adj = { { 0, 1, 1, 1, 0 },
{ 1, 0, 1, 0, 1 },
{ 1, 1, 0, 1, 1 },
{ 1, 0, 1, 0, 0 } };
int N = adj.GetLength(0);
if (Hamiltonian_path(adj, N))
Console.WriteLine( "YES" );
else
Console.WriteLine( "NO" );
}
}
|
Javascript
<script>
var N = 5;
function Hamiltonian_path( adj, N)
{
var dp = Array.from(Array(N), ()=> Array(1 << N).fill(0));
for ( var i = 0; i < N; i++)
dp[i][(1 << i)] = true ;
for ( var i = 0; i < (1 << N); i++) {
for ( var j = 0; j < N; j++) {
if (i & (1 << j)) {
for ( var k = 0; k < N; k++) {
if (i & (1 << k)
&& adj[k][j]
&& j != k
&& dp[k][i ^ (1 << j)]) {
dp[j][i] = true ;
break ;
}
}
}
}
}
for ( var i = 0; i < N; i++) {
if (dp[i][(1 << N) - 1])
return true ;
}
return false ;
}
var adj = [ [ 0, 1, 1, 1, 0 ],
[ 1, 0, 1, 0, 1 ],
[ 1, 1, 0, 1, 1 ],
[ 1, 0, 1, 0, 0 ] ];
var N = adj.length;
if (Hamiltonian_path(adj, N))
document.write( "YES" );
else
document.write( "NO" );
</script>
|
Time Complexity: O(N2 * 2N)
Auxiliary Space: O(N * 2N)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...