Number of Squareful Arrays - Problem

Array Hash Table Math Dynamic Programming Backtracking Bit Manipulation Bitmask Hard

An array is squareful if the sum of every pair of adjacent elements is a perfect square.

Given an integer array nums, return the number of permutations of nums that are squareful.

Two permutations perm1 and perm2 are different if there is some index i such that perm1[i] != perm2[i].

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,17,8]

› Output: 2

💡 Note: Two valid permutations: [1,8,17] (1+8=9=3², 8+17=25=5²) and [17,8,1] (17+8=25=5², 8+1=9=3²)

Example 2 — No Valid Permutations

$ Input: nums = [2,2,2]

› Output: 1

💡 Note: Only one arrangement [2,2,2], and 2+2=4=2² for all adjacent pairs, so it's squareful

Example 3 — Empty Result

$ Input: nums = [2,3,5]

› Output: 0

💡 Note: No two numbers sum to a perfect square: 2+3=5, 2+5=7, 3+5=8, none are perfect squares

Constraints

1 ≤ nums.length ≤ 12
0 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 a Amazon 15

The key insight is to model this as a graph problem where edges connect numbers that sum to perfect squares. The optimal approach uses backtracking with adjacency graph to avoid generating invalid permutations. Time: O(n! × √max_sum), Space: O(n²)

Common Approaches

✓ Backtracking with Graph

⏱️ Time: O(n! × √max_sum) Space: O(n²)

Create a graph where edges connect numbers that sum to perfect squares. Use backtracking to build valid permutations by only exploring valid paths, avoiding generating invalid permutations.

Brute Force Permutations

⏱️ Time: O(n! × n) Space: O(n)

Generate all possible permutations of the array and for each permutation, check if every adjacent pair sums to a perfect square. Count valid permutations.

Backtracking with Graph — Algorithm Steps

Build adjacency graph for numbers that sum to perfect squares
Use backtracking to build permutations following graph edges
Handle duplicates by tracking frequency
Count valid complete permutations

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Connect numbers that sum to perfect squares

Backtrack

Follow valid paths to build permutations

Count Solutions

Count complete valid permutations

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define MAX_NUMS 12

int isPerfectSquare(int n) {
    if (n < 0) return 0;
    int root = (int) sqrt(n);
    return root * root == n;
}

static int unique[MAX_NUMS];
static int graph[MAX_NUMS * MAX_NUMS];
static int graphSize[MAX_NUMS];
static int count[MAX_NUMS];

int backtrack(int currIdx, int remaining, int uniqueSize) {
    if (remaining == 0) {
        return 1;
    }
    
    int result = 0;
    for (int i = 0; i < graphSize[currIdx]; i++) {
        int nextNum = graph[currIdx * MAX_NUMS + i];
        int nextIdx = -1;
        for (int j = 0; j < uniqueSize; j++) {
            if (unique[j] == nextNum) {
                nextIdx = j;
                break;
            }
        }
        if (nextIdx != -1 && count[nextIdx] > 0) {
            count[nextIdx]--;
            result += backtrack(nextIdx, remaining - 1, uniqueSize);
            count[nextIdx]++;
        }
    }
    return result;
}

int solution(int* nums, int size) {
    // Build unique numbers list
    int uniqueSize = 0;
    for (int i = 0; i < size; i++) {
        int found = 0;
        for (int j = 0; j < uniqueSize; j++) {
            if (unique[j] == nums[i]) {
                found = 1;
                break;
            }
        }
        if (!found) {
            unique[uniqueSize++] = nums[i];
        }
    }
    
    // Build adjacency graph
    for (int i = 0; i < uniqueSize; i++) {
        graphSize[i] = 0;
        for (int j = 0; j < uniqueSize; j++) {
            if (isPerfectSquare(unique[i] + unique[j])) {
                graph[i * MAX_NUMS + graphSize[i]++] = unique[j];
            }
        }
    }
    
    // Count frequency of each number
    for (int i = 0; i < uniqueSize; i++) {
        count[i] = 0;
    }
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < uniqueSize; j++) {
            if (nums[i] == unique[j]) {
                count[j]++;
                break;
            }
        }
    }
    int total = size;
    
    int result = 0;
    for (int i = 0; i < uniqueSize; i++) {
        if (count[i] > 0) {
            count[i]--;
            result += backtrack(i, total - 1, uniqueSize);
            count[i]++;
        }
    }
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[MAX_NUMS];
    int size;
    parseArray(line, nums, &size);
    
    printf("%d\n", solution(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × √max_sum)

Worst case still n! permutations, but with early pruning and √max_sum for perfect square checks

⚠ Quadratic Growth

Space Complexity

O(n²)

Adjacency graph storage plus recursion stack depth

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Number of Squareful Arrays - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Graph — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler