Number of Squareful Arrays in Java

An array containing only positive numbers is provided as input. We have to find out the total number of Squareful permutations of the array. An array is known as Squareful if the sum of each pair of adjacent elements is a perfect square.

Example 1:

Input

int inArr[] = {1, 3, 6}

Output

Explanation:

There are 6 permutations possible for the given array. {1, 3, 6}, {1, 6, 3}, {3, 1, 6}, {3, 6, 1}, {6, 1, 3}, {6, 3, 1}. In all of these 6 permutations, only {1, 3, 6}, and {6, 3, 1} form the Squareful arrays. For {1, 3, 6} we have 1 + 3 = 4 (2²) and 3 + 6 = 9 (3²), and for {6, 3, 1} we have 6 + 3 = 9 (3²), and 1 + 3 = 4 (2²).

Example 2:

Input

int inArr[] = {24, 48, 1}

Output

Explanation:

There are 6 permutations possible for the given array. {1, 24, 48}, {1, 48, 24}, {24, 1, 48}, {24, 48, 1}, {48, 1, 24}, {48, 24, 1}. In all of these 6 permutations, only {24, 1, 48}, and {48, 1, 24} form the Squareful arrays. For {24, 1, 48} we have 24 + 1 = 25 (5²) and 1 + 48 = 49 (7²), and for {48, 1, 24} we have 48 + 1 = 49 (7²), and 1 + 24 = 25 (5²).

Example 2:

Input

int inArr[] = {0, 0, 4, 0, 0}

Output

Explanation:

There are 5 permutations possible for the given array. {0, 0, 0, 0, 4}, {0, 0, 0, 4, 0}, {0, 0, 4, 0, 0}, {0, 4, 0, 0, 0}, {4, 0, 0, 0, 0}. All of these permutations are Squareful arrays. For {0, 0, 0, 0, 4}, we have 0 + 0 = 0 (0²), 0 + 0 = 0 (0²), 0 + 0 = 0 (0²), 0 + 4 = 4 (2²). Similar logic can be given for the other permutations too.

Simple Approach: Brute Force

In this approach, we check all of the permutations of the input array. And for every permutation in the input array 'inAr', check whether inAr[j] + inAr[j+1] is a perfect square or not. If it is a perfect square, then increase the ans by 1. Then return ans.

Algorithm:

Method for checking whether a specific permutation of 'inAr' is Squareful or not.
- Make a method bool checkSquareful (int inAr[], int n)
- Iterate 'j' from 0 to the length of 'inAr'.
  - If floor(sqrt(inAr[i] + inAr [i+1] )) != ceil(sqrt(inAr [i] + inAr[i+1])), return false.
- Otherwise, return false.
Method for counting all of the Squareful permutations
- Initialize an int 'cnt' = 0;
- Sort the array 'inAr' in ascending order.
- Run a do-while loop to check for all of the Squareful permutations.
- do -> if checkSquareful (inAr) , then increase 'cnt'.
- While keep checking for the next permutation of 'inAr'.

Now observe the following implementation.

Filename: SquarefulArrays.java

// importing Arrays for performing sorting
import java.util.Arrays;

public class SquarefulArrays 
{    
// method that swaps elements located at the indices l and r
public static int[] swapEle(int inAr[], int l, int r)
{        
    int tmp = inAr[l];
    inAr[l] = inAr[r];
    inAr[r] = tmp;

    return inAr;
}

// reversing the array from l to r
public static int[] reverseArr(int inAr[], int l, int r)
{  
    while (l < r) 
    {
        int tmp = inAr[l];
        inAr[l] = inAr[r];
        l = l + 1;
        inAr[r] = tmp;
        r = r - 1;
    }

    return inAr;
}

// a method that finds the next permutation of the input array inAr[]
public static boolean nxtPermutation(int inAr[])
{

    if (inAr.length <= 1)
    {
        return false;
    }
    
    int lst = inAr.length - 2;

    // starting from the right, we move to left
    // and when two elements where the first element is lesser
    // than the next element, then the loop terminates.
    while (lst >= 0) 
    {
        if (inAr[lst] < inAr[lst + 1]) 
        {
            break;
        }

        lst = lst - 1;
    }

    if (lst < 0)
    {
        return false;
    }

    // finding the index of next greater element
    int nextGrtr = inAr.length - 1;
    for (int j = inAr.length - 1; j > lst; j--) 
    {
        if (inAr[j] > inAr[lst]) 
        {
            nextGrtr = j;
            break;
        }
    }

    // 
    inAr = swapEle(inAr, nextGrtr, lst);
    inAr = reverseArr(inAr, lst + 1, inAr.length - 1); 
    return true;
}

// Checking whether the input array is squareful or not.
public static boolean checkSquareful(int[] inAr, int n)
{
    for (int j = 0; j < n - 1; j++)
    {
        // if the sum of the element pointed by the loop variable and the next adjacent element is not a perfect
        // square, then the permutation forms the squareful array otherwise, not.
        if (Math.ceil(Math.sqrt(inAr[j] + inAr[j + 1])) != Math.floor(Math.sqrt(inAr[j] + inAr[j + 1])))
        {
            return false;
        }
    }

    return true;
}

// a method that computes the number of squareful arrays
public static int numberOfSquarefulArr(int[] inAr, int s) 
{
    int cnt = 0;
    
    // sorting the elements in the ascending order
    Arrays.sort(inAr);
    
    // Checking all of the permutations.
    do
    {
        if (checkSquareful(inAr, s))
        {
            // for every permutation that gives the
            // squareful array, the cnt is increased by 1
            cnt = cnt + 1;
        }
    
    } while (nxtPermutation(inAr));

    return cnt;
}


// main method
public static void main(String argvs[])
{
    
    // creating an object of the class SquarefulArrays
    SquarefulArrays obj = new SquarefulArrays();
    
    int inAr[] = {0, 0, 0, 0, 4}; // input array
    int size = inAr.length; // size of the input array
    
    
    System.out.println("For the input array: ");
    for(int j = 0 ; j < size; j++)
    {
    System.out.print(inAr[j] + " ");
    }
    
    // invoking the method numberOfSquarefulArr() and storing the answer
    int ans = obj.numberOfSquarefulArr(inAr, size);
    System.out.println();
    System.out.println("The number of Squareful array is: " + ans + "\n");
    
    int inAr1[] = {1, 3, 6}; // input array
    size = inAr1.length; // size of the input array
    
    System.out.println("For the input array: ");
    for(int j = 0 ; j < size; j++)
    {
    System.out.print(inAr1[j] + " ");
    }

    // invoking the method numberOfSquarefulArr() and storing the answer
    ans = obj.numberOfSquarefulArr(inAr1, size);
    System.out.println();
    System.out.println("The number of Squareful array is: " + ans + "\n");
    
    int inAr2[] = {24, 48, 1}; // input array
    size = inAr2.length; // size of the input array
    
    
    System.out.println("For the input array: ");
    for(int j = 0 ; j < size; j++)
    {
    System.out.print(inAr2[j] + " ");
    }
    
    // invoking the method numberOfSquarefulArr() and storing the answer
    ans = obj.numberOfSquarefulArr(inAr2, size);
    System.out.println();
    System.out.println("The number of Squareful array is: " + ans + "\n");
    
}
}

Output:

For the input array: 
0 0 0 0 4 
The number of Squareful array is: 5

For the input array: 
1 3 6 
The number of Squareful array is: 2

For the input array: 
24 48 1 
The number of Squareful array is: 2

Complexity Analysis: For the N size of the array, there are a total number of N! permutation. We are checking all of the permutations and each permutation is of the size N. Therefore, the overall time complexity of the program is O(N! * N). The space complexity of the program is O(1), as the program is not using any extra space.

The time complexity of the program is very high and is not suitable for larger inputs. Hence, some optimization is required. Observe the following approach.

Approach: Dynamic Programming Force

Make a graph where an edge exit from j to k if inAr[j] + inAr[k] is a perfect square. After that, count all of the possible Hamiltonian paths. Total number of Hamiltonian paths will be equal to the number of permutations that are Squareful.

Hamiltonian path is a graph path between two vertices of a graph such that all visit all the vertices of the graph at least once.

We will be constructing the graph where an edge between 'j' and 'k' is only if inAr[j] + inAr[k] is a perfect square. We can use dynamic programming techniques to check for the Hamiltonian paths.

Algorithm:

Step 1: We will first discard the repetitions and will only consider the index permutations. P[B, j] represents the total number of permutations when 'B' keeps the number we had already used, inAr[j] is the last number.

Step 2: 'B' is the binary number, where every bit represents where 'j' exits or not.

Step 3: In the beginning, P[1 << j, j] = 1. Other states are 0.

Step 4: Each time, enumerate 'k'.

If 'k' is not 'S', and inAr[j]+ inAr[k] is the perfect square, then,
- P[B|1 << k, k] += P[B, j]

Step 5: Take a variable 'ans'. Assign value 0 to it.

Step 6: Iterate using 'j' from 0 to 's', where the size of the input array 'inAr' is 's'.

We get, 'ans' += P[(1 << s) - 1, j]

Step 7: It is required to count the repeated elements only once. Therefore divide 'ans' from the factorial of the count of every number in 'inAr[]'.

Filename: SquarefulArrays.java

// import statements
import java.util.Arrays;
import java.util.ArrayList;

public class SquarefulArrays
{
// a method that checks whether r is
// is a perfect square or not
public static boolean isSquare(int r) 
{
int t = (int)Math.sqrt(r);
return (t * t == r);
}

// a method that finds the factorial of num x
public static int fact(int x) 
{

int f = 1;
for (int j = 2; j <= x; j++) 
{
    f = f * j;
}

return f;
}


public static int numberOfSquarefulArr(int[] inAr, int s) 
{
Arrays.sort(inAr);

// list contains the number of times an element is repeated
// inn the input array inAr[]
ArrayList <Integer> al = new ArrayList<>();
int cnt = 1;
for (int i = 1; i < s; i++) 
{
    if (inAr[i] != inAr[i - 1]) 
	{
        al.add(cnt);
        cnt = 0;
    }

    cnt = cnt + 1;
}

al.add(cnt);


int P[][] = new int[1 << s][s];

for (int i = 0; i < s; i++) 
{
    P[1 << i][i] = 1;
}

// considering all the pairs which  
// may or may not make the perfect square
for (int k = 1; k < (1 << s); k++) 
{
    for (int i = 0; i < s; i++) 
	{
        if ((k & (1 << i)) != 0) 
		{
            for (int j = 0; j < s; j++) 
			{
                if ((k & (1 << j)) == 0 && isSquare(inAr[i] + inAr[j])) 
				{
                    P[k | (1 << j)][j] = P[k | (1 << j)][j] + P[k][i];
                }
            }
        }
    }
}

int ans = 0;
for (int k = 0; k < s; k++)
{
    ans = ans + P[(1 << s) - 1][k];
}

// a loop that handles repetition
for (int k = 0; k < al.size(); k++) 
{
    ans = ans / fact(al.get(k));
}	

return ans;
}


// main method
public static void main(String argvs[])
{
    
    // creating an object of the class SquarefulArrays
    SquarefulArrays obj = new SquarefulArrays();
    
    int inAr[] = {0, 0, 0, 0, 4}; // input array
    int size = inAr.length; // size of the input array
    
    
    System.out.println("For the input array: ");
    for(int j = 0 ; j < size; j++)
    {
    System.out.print(inAr[j] + " ");
    }
    
    // invoking the method numberOfSquarefulArr() and storing the answer
    int ans = obj.numberOfSquarefulArr(inAr, size);
    System.out.println();
    System.out.println("The number of Squareful array is: " + ans + "\n");
    
    int inAr1[] = {1, 3, 6}; // input array
    size = inAr1.length; // size of the input array
    
    System.out.println("For the input array: ");
    for(int j = 0 ; j < size; j++)
    {
    System.out.print(inAr1[j] + " ");
    }

    // invoking the method numberOfSquarefulArr() and storing the answer
    ans = obj.numberOfSquarefulArr(inAr1, size);
    System.out.println();
    System.out.println("The number of Squareful array is: " + ans + "\n");
    
    int inAr2[] = {24, 48, 1}; // input array
    size = inAr2.length; // size of the input array
    
    
    System.out.println("For the input array: ");
    for(int j = 0 ; j < size; j++)
    {
    System.out.print(inAr2[j] + " ");
    }
    
    // invoking the method numberOfSquarefulArr() and storing the answer
    ans = obj.numberOfSquarefulArr(inAr2, size);
    System.out.println();
    System.out.println("The number of Squareful array is: " + ans + "\n");
    
}
}

Output:

For the input array: 
0 0 0 0 4 
The number of Squareful array is: 5

For the input array: 
1 3 6 
The number of Squareful array is: 2

For the input array: 
24 48 1 
The number of Squareful array is: 2

Complexity Analysis: There are a total of 'N x 2N' states, and for each state, there are up to 'N' children. Also, each child is traversed at least once. Therefore, the overall time complexity of the program is O(N2 x 2N). Also, the program uses a two-dimensional array 'P', which makes the space complexity of the program O(N x 2N), where N is the size of the input array.

Next TopicOne-Time Password Generator Code In Java

← prev next →

Number of Squareful Arrays in Java

Simple Approach: Brute Force

Algorithm:

Approach: Dynamic Programming Force

Algorithm:

Latest Courses

Contact info

Follow us

Tutorials

Interview Questions

Online Compiler

Frontend

Data Analytics

Database

Online Compiler

Backend

Technical Interview

Java Interview

Web Interview

Database Interview

Company Interviews

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

Java String

Java String Methods

Java Regex

Exception Handling

Java Inner Class

Java Multithreading

Java Synchronization

Java Networking

Java Applet

Java Reflection

Java Conversion

Java JDBC

RMI

Internationalization

Java Array Class

Java AtomicInteger Class

Java AtomicLong Methods

Java Authenticator

Java BigDecimal class

Big Integer Class

Java Boolean class

Java Byte Class

Java Class

Java Collections class

Java Compiler Class

CopyOnWriteArrayList

Java Math Methods

LinkedBlockingDeque

Java Long class

LinkedTransferQueue

Java List

Java MulticastSocket

Java Number Class

Java Phaser Class

ArrayList Methods

Java Thread Methods

Java Projects

Java Programs

Java Misc

Number of Squareful Arrays in Java

Simple Approach: Brute Force

Algorithm:

Approach: Dynamic Programming Force

Algorithm:

Latest Courses

Contact info

Follow us

Tutorials

Interview Questions

Online Compiler