Minimum Perfect Squares that sums to N

//Driver Code Starts
#include <stdio.h>
#include <math.h>
//Driver Code Ends


int minSquares(int n) {
    // minSquares(0) = 0
    if (n == 0)
        return 0;

    // n = 1*1 + 1*1 .... n times
    // so we can initialise count with n
    int cnt = n;


    // Go through all smaller numbers 
    // to recursively find minimum
    for (int x = 1; x * x <= n; x++) {
        int temp = 1 + minSquares(n - x * x);
        if (temp < cnt)
            cnt = temp;
    }
    return cnt;
}


//Driver Code Starts
int main() {
    int n = 6;
    printf("%d
", minSquares(n));
    return 0;
}

//Driver Code Ends

//Driver Code Starts
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
//Driver Code Ends


int minSquaresRec(int n, int dp[]) {
  
    // base case
    if (n == 0)
        return n;
    
    // if the result for this subproblem is already
    // computed then return it
    if (dp[n] != -1)
        return dp[n];
    
    // n = 1*1 + 1*1 .... n times
    // so we can initialise count with n
    int cnt = n;
    
    // Go through all smaller numbers
    //  to recursively find minimum
    for (int x = 1; x * x <= n; x++) {
        int temp = 1 + minSquaresRec(n - x * x, dp);
        if (temp < cnt)
            cnt = temp;
    }
    
    // store the result of this problem
    dp[n] = cnt;
    return cnt;
}

int minSquares(int n) {
  
    // dp array to store the results
    int* dp = (int*)malloc((n + 1) * sizeof(int));
    for (int i = 0; i <= n; i++)
        dp[i] = -1;

    int result = minSquaresRec(n, dp);
    free(dp);
    return result;
}


//Driver Code Starts
int main() {
    int n = 6;
    printf("%d
", minSquares(n));
    return 0;
}

//Driver Code Ends

//Driver Code Starts
#include <stdio.h>
#include <stdlib.h>
//Driver Code Ends


int minSquares(int n) {
  
    // Memoization array to store the results
    int* dp = (int*)malloc((n + 1) * sizeof(int));
  
    // base cases
    dp[0] = 0;
    dp[1] = 1;
    
    for (int i = 2; i <= n; i++) {
      
        dp[i] = i;
        for (int x = 1; x * x <= i; ++x) {
            
            // recursive case
            int temp = 1 + dp[i - x * x];
            if (temp < dp[i])
                dp[i] = temp;
        }
    }
  
    int result = dp[n];
    free(dp);
    return result;
}


//Driver Code Starts
int main() {
    int n = 6;
    printf("%d", minSquares(n));
    return 0;
}

//Driver Code Ends

//Driver Code Starts
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

struct Pair {
    int node;
    int steps;
};

struct Queue {
    struct Pair* arr;
    int front, rear, size, capacity;
};

struct Queue* createQueue(int capacity) {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->capacity = capacity;
    q->front = q->rear = q->size = 0;
    q->arr = (struct Pair*)malloc(capacity * sizeof(struct Pair));
    return q;
}

void enqueue(struct Queue* q, struct Pair val) {
    q->arr[q->rear++] = val;
    q->size++;
}

struct Pair dequeue(struct Queue* q) {
    return q->arr[q->front++];
}

int isEmpty(struct Queue* q) {
    return q->size == 0;
}

//Driver Code Ends

int minSquares(int n) {
  
    // Creating visited array of size n + 1
    bool* vis = (bool*)calloc(n + 1, sizeof(bool));
  
    // Queue of pair to store number and count
    // of steps to reach that number from n by 
    // subtacting a square in each step
    struct Queue* q = createQueue(n * n + 1);
  
    // Push initial number
    enqueue(q, (struct Pair){n, 0});
  
    // Mark starting node visited
    vis[n] = true;

    while (!isEmpty(q)) {
        struct Pair p = dequeue(q);
        int node = p.node;
        int steps = p.steps;
     
        if (node == 0)
            return steps;
      
        // Loop for all possible path 
        // from 1 to i*i <= current node
        for (int i = 1; i * i <= node; i++) {
          
            int next = node - (i * i);
            if (!vis[next]) {
              
                // Mark visited
                vis[next] = true;
              
                // Push it it Queue
                enqueue(q, (struct Pair){next, steps + 1});
            }
        }
    }
    return -1;
}

//Driver Code Starts

int main() {
    int n = 6;
    printf("%d", minSquares(n));
    return 0;
}

//Driver Code Ends

//Driver Code Starts
#include <stdio.h>
#include <math.h>
//Driver Code Ends


int isSquare(int x) {
    int sqRoot = sqrt(x);
    return (sqRoot * sqRoot == x);
}

int minSquares(int n) {
  
    // if n is a perfect square
    if (isSquare(n)) {
        return 1;
    }

    // if the number is the
    // sum of two perfect squares
    for (int i = 1; i * i <= n; i++) {
        if (isSquare(n - (i * i))) {
            return 2;
        }
    }

    // if n is of the form 4^a (8*b + 7).
    while (n > 0 && n % 4 == 0) {
        n /= 4;
    }
    if (n % 8 == 7) {
        return 4;
    }

    // since all the other cases have been evaluated, 
    // the answer can only then be 3 if the program 
    // reaches here
    return 3;
}


//Driver Code Starts
int main() {
    int n = 6;
    printf("%d
", minSquares(n));
    return 0;
}

//Driver Code Ends