Minimum perfect squares to add that sum to given number.

// Java program to find minimum number of squares whose 
// sum is equal to a given number using recursion

class GfG {
  	
  	// Function to find count of minimum squares 
	// that sum to n
    static int minSquares(int n) {
      
        // base case: minSquares(1) = 1
        // minSquares(2) = 2
        // minSquares(3) = 3
        if (n <= 3)
            return n;

        // Any positive number n, can be represented 
        // as sum of 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++) {
            cnt = Math.min(cnt, 1 + minSquares(n - x * x));
        }
        return cnt;
    }

    public static void main(String[] args) {
        int n = 6;
        System.out.println(minSquares(n));
    }
}

// Java program to find minimum number of squares whose 
// sum is equal to a given number using memoization
import java.util.Arrays;

class GfG {
  
    // Function to find count of minimum 
  	// squares that sum to n
    static int minSquaresRec(int n, int[] memo) {
      
        // base case: minSquares(1) = 1
        // minSquares(2) = 2
        // minSquares(3) = 3
        if (n <= 3)
            return n;
        
        // if the result for this subproblem is 
      	// already computed then return it
        if (memo[n] != -1)
            return memo[n];
        
        // Any positive number n, can be represented 
      	// as sum of 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++) {
            cnt = Math.min(cnt, 1 + minSquaresRec(n - x * x, memo));
        }
        
        // store the result of this problem to 
      	// avoid re computation
        return memo[n] = cnt;
    }

    static int minSquares(int n) {
      
        // Memoization array to store
      	// the results
        int[] memo = new int[n + 1];
        Arrays.fill(memo, -1);
        return minSquaresRec(n, memo);
    }

    public static void main(String[] args) {
        int n = 6;
        System.out.println(minSquares(n));
    }
}

// Java program to find minimum number of squares whose 
// sum is equal to a given number Using Bottom-Up DP
import java.util.Arrays;

class GfG {
  
    static int minSquares(int n) {
      
        // Memoization array to store the results
        int[] dp = new int[n + 1];
        
        // base case
        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
                dp[i] = Math.min(dp[i], 1 + dp[i - x * x]);
            }
        }
        
        return dp[n];
    }

    public static void main(String[] args) {
        int n = 6;
        System.out.println(minSquares(n));
    }
}

// Java program to find minimum number of squares 
// whose sum is equal to a given number 
// Using Breadth-First Search
import java.util.*;

class GfG {
    static int minSquares(int n) {
      
        // Creating visited array of size n + 1
        boolean[] vis = new boolean[n + 1];
        int res = n;
      
        // Queue of pair to store node and number
      	// of steps
        Queue<int[]> q = new LinkedList<>();
      
        // Push starting node with 0
        // 0 indicate current number of step to reach n
        q.add(new int[]{n, 0});
      
        // Mark starting node visited
        vis[n] = true;

        while (!q.isEmpty()) {
            int[] p = q.poll();
            int node = p[0];
            int steps = p[1];
          
            // If node reaches its destination 0 
          	// update answer
            if (node == 0)
                res = Math.min(res, steps);
          
            // Loop for all possible path 
          	// from 1 to i*i <= current node
            for (int i = 1; i * i <= node; i++) {
              
                // If we are standing at some node then 
              	// next node it can jump to will be 
              	// current node - (some square less than or equal n)
                int path = (node - (i * i));
              
                // Check if it is valid and not visited yet
                if (path >= 0 && (!vis[path] || path == 0)) {
                  
                    // Mark visited
                    vis[path] = true;
                  
                    // Push it it Queue
                    q.add(new int[]{path, steps + 1});
                }
            }
        }
        return res;
    }

    public static void main(String[] args) {
        int n = 6;
        System.out.println(minSquares(n));
    }
}

// Java program to find minimum number of squares 
// whose sum is equal to a given number 
// Using Unbounded Knapsack Concept
import java.util.ArrayList;

class GfG {
  
    // Function to count minimum 
    // squares that sum to n 
    static int minSquares(int n) {
      
        // Making the array of perfect squares 
        // less than or equal to n
        ArrayList<Integer> arr = new ArrayList<>();
        int i = 1;
        while (i * i <= n) {
            arr.add(i * i);
            i++;
        }

        // A dp array which will store minimum number 
        // of perfect squares required to make n 
        // from i at i th index
        int[] dp = new int[n + 1];
        for (i = 1; i <= n; i++) {
            dp[i] = n;
        }
      
        dp[0] = 0;

        for (i = 1; i <= n; i++) {
            for (int j = 0; j < arr.size(); j++) {
                if (i >= arr.get(j)) {
                    dp[i] = Math.min(dp[i], 
                             dp[i - arr.get(j)] + 1);
                }
            }
        }

        return dp[n];
    }

    public static void main(String[] args) {
        int n = 6;
        System.out.println(minSquares(n));
    }
}

// Java program to find minimum number of squares 
// whose sum is equal to a given number 
// Using Lagrange's Four Square Theorem
class GfG {

    // returns true if the number x is a square number,
    // else returns false
    static boolean isSquare(int x) {
        int sqRoot = (int) Math.sqrt(x);
        return (sqRoot * sqRoot == x);
    }

    // Function to count minimum squares that sum to n
    static int minSquares(int n) {
      
        // Case 1: ans = 1 if the number itself is a 
        // perfect square
        if (isSquare(n)) {
            return 1;
        }

        // Case 2: ans = 2 if the number is a sum of 
        // two perfect square
        // we check for each i if n - (i * i) is a perfect
        // square
        for (int i = 1; i * i <= n; i++) {
            if (isSquare(n - (i * i))) {
                return 2;
            }
        }

        // Case 4: ans = 4 if the number is a sum of 
        // four perfect square
        // possible if the number is representable in 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;
    }

    public static void main(String[] args) {
        int n = 6;
        System.out.println(minSquares(n));
    }
}