Permutation of numbers such that sum of two consecutive numbers is a perfect square

import java.util.*;

public class HamiltonianPath {

    // Function to check if a node is safe to visit in the
    // current Hamiltonian path
    static boolean issafe(int v, int[][] graph, int[] path,
                          int pos)
    {
        // Check if the current node is connected to the
        // previous node in the path
        if (graph[path[pos - 1]][v] == 0) {
            return false;
        }

        // Check if the current node has already been
        // visited in the current path
        for (int i = 0; i < pos; i++) {
            if (path[i] == v) {
                return false;
            }
        }

        // If the current node is connected to the previous
        // node and has not been visited yet, return true
        return true;
    }

    // Function to form the Hamiltonian path by visiting
    // nodes recursively
    static boolean formpath(int[][] graph, int[] path,
                            int pos, int n)
    {
        // If all the nodes have been visited, return true
        if (pos == n + 1) {
            return true;
        }

        // Try visiting each node and see if it forms a
        // Hamiltonian path
        for (int v = 1; v < n + 1; v++) {
            if (issafe(v, graph, path, pos)) {
                path[pos] = v;
                if (formpath(graph, path, pos + 1, n)
                    == true) {
                    return true;
                }
                path[pos] = -1;
            }
        }
        // If none of the nodes form a Hamiltonian path,
        // return false
        return false;
    }

    // Function to find a Hamiltonian path in a given graph
    static void hampath(int n)
    {
        // Adjacency matrix to store the graph
        int[][] graph = new int[n+1][n+1];
        // Array to store the Hamiltonian path
        int[] path = new int[n+1];

        // If there is only 1 node in the graph, there is no
        // Hamiltonian path
        if (n == 1) {
            System.out.println("No Solution");
            return;
        }

        // Vector to store the squares of the numbers from 1
        // to sqrt(2n-1)
        ArrayList<Integer> l = new ArrayList<Integer>();
        int nsqrt = (int)Math.sqrt(2 * n - 1);
        for (int i = 1; i <= nsqrt + 1; i++) {
            l.add(i * i);
        }

        // Initialize the graph to 0
        for (int i = 1; i < n + 1; i++) {
            for (int j = 1; j < n + 1; j++) {
                graph[i][j] = 0;
            }
        }

        // Form the graph using the squares stored in the
        // vector 'l'
        for (int i = 1; i < n + 1; i++) {
            for (int ele : l) {
                // Check if the difference between the
                // square and the current node is greater
                // than 0 and less than or equal to n Also,
                // make sure that the difference is not
                // equal to 2 times the current node (to
                // avoid repeated edges)
                if ((ele - i) > 0 && (ele - i) <= n
                    && (2 * i != ele)) {
                    graph[i][ele - i] = 1;
                    graph[ele - i][i] = 1;
                }
            }
        }

        for (int j = 1; j < n + 1; j++) {
            // Reset the path array
            Arrays.fill(path, -1);
            // Start the path from vertex j
            path[1] = j;
            // Check if a Hamiltonian path can be formed
            // starting from vertex j
            if (formpath(graph, path, 2, n) == true) {
                System.out.print("Hamiltonian Path: ");
                // Print the path
                for (int i = 1; i < n + 1; i++) {
                    System.out.print(path[i] + " ");
                }
                // Return the path
                return;
            }
        }
        // If no solution is found, print "No Solution"
        System.out.print("No Solution");
    }
    public static void main(String[] args)
    {
        System.out.print("17 -> ");
        hampath(17);
        System.out.println();
        System.out.print("20 -> ");
        hampath(20);
        System.out.println();
        System.out.print("25 -> ");
        hampath(25);
    }
}