Related Articles

# Minimum number of squares whose sum equals to given number n

• Difficulty Level : Medium
• Last Updated : 18 Jul, 2021

A number can always be represented as a sum of squares of other numbers. Note that 1 is a square and we can always break a number as (1*1 + 1*1 + 1*1 + …). Given a number n, find the minimum number of squares that sum to X.

Examples :

Input:  n = 100
Output: 1
Explanation:
100 can be written as 102. Note that 100 can also be written as 52 + 52 + 52 + 52, but this representation requires 4 squares.

Input:  n = 6
Output: 3

The idea is simple, we start from 1 and go to a number whose square is smaller than or equals n. For every number x, we recur for n-x. Below is the recursive formula.

`If n = 1 and x*x <= n`

Below is a simple recursive solution based on the above recursive formula.

## C++

 `// A naive recursive C++``// program to find minimum``// number of squares whose sum``// is equal to a given number``#include ``using` `namespace` `std;` `// Returns count of minimum``// squares that sum to n``int` `getMinSquares(unsigned ``int` `n)``{``    ``// base cases``    ``// if n is perfect square then``    ``// Minimum squares required is 1``    ``// (144 = 12^2)``    ``if` `(``sqrt``(n) - ``floor``(``sqrt``(n)) == 0)``        ``return` `1;``    ``if` `(n <= 3)``        ``return` `n;` `    ``// getMinSquares rest of the``    ``// table using recursive``    ``// formula``    ``// Maximum squares required``    ``// is n (1*1 + 1*1 + ..)``    ``int` `res = n;` `    ``// Go through all smaller numbers``    ``// to recursively find minimum``    ``for` `(``int` `x = 1; x <= n; x++)``    ``{``        ``int` `temp = x * x;``        ``if` `(temp > n)``            ``break``;``        ``else``            ``res = min(res, 1 + getMinSquares``                                  ``(n - temp));``    ``}``    ``return` `res;``}` `// Driver code``int` `main()``{``    ``cout << getMinSquares(6);``    ``return` `0;``}`

## Java

 `// A naive recursive JAVA``// program to find minimum``// number of squares whose``// sum is equal to a given number``class` `squares``{``    ` `    ``// Returns count of minimum``    ``// squares that sum to n``    ``static` `int` `getMinSquares(``int` `n)``    ``{``        ` `        ``// base cases``        ``if` `(n <= ``3``)``            ``return` `n;` `        ``// getMinSquares rest of the``        ``// table using recursive``        ``// formula``        ``// Maximum squares required is``        ``int` `res = n;``        ``// n (1*1 + 1*1 + ..)` `        ``// Go through all smaller numbers``        ``// to recursively find minimum``        ``for` `(``int` `x = ``1``; x <= n; x++)``        ``{``            ``int` `temp = x * x;``            ``if` `(temp > n)``                ``break``;``            ``else``                ``res = Math.min(res, ``1` `+``                          ``getMinSquares(n - temp));``        ``}``        ``return` `res;``    ``}``  ` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``System.out.println(getMinSquares(``6``));``    ``}``}``/* This code is contributed by Rajat Mishra */`

## Python

 `# A naive recursive Python program to``# find minimum number of squares whose``# sum is equal to a given number` `# Returns count of minimum squares``# that sum to n``def` `getMinSquares(n):` `    ``# base cases``    ``if` `n <``=` `3``:``        ``return` `n;` `    ``# getMinSquares rest of the table``    ``# using recursive formula``    ``# Maximum squares required``    ``# is n (1 * 1 + 1 * 1 + ..)``    ``res ``=` `n` `    ``# Go through all smaller numbers``    ``# to recursively find minimum``    ``for` `x ``in` `range``(``1``, n ``+` `1``):``        ``temp ``=` `x ``*` `x;``        ``if` `temp > n:``            ``break``        ``else``:``            ``res ``=` `min``(res, ``1` `+` `getMinSquares(n``                                  ``-` `temp))``    ` `    ``return` `res;` `# Driver code``print``(getMinSquares(``6``))` `# This code is contributed by nuclode`

## C#

 `// A naive recursive C# program``// to find minimum number of``// squares whose sum is equal``// to a given number``using` `System;` `class` `GFG``{` `    ``// Returns count of minimum``    ``// squares that sum to n``    ``static` `int` `getMinSquares(``int` `n)``    ``{` `        ``// base cases``        ``if` `(n <= 3)``            ``return` `n;` `        ``// getMinSquares rest of the``        ``// table using recursive``        ``// formula` `        ``// Maximum squares required is``        ``// n (1*1 + 1*1 + ..)``        ``int` `res = n;` `        ``// Go through all smaller numbers``        ``// to recursively find minimum``        ``for` `(``int` `x = 1; x <= n; x++)``        ``{``            ``int` `temp = x * x;``            ``if` `(temp > n)``                ``break``;``            ``else``                ``res = Math.Min(res, 1 +``                      ``getMinSquares(n - temp));``        ``}``        ``return` `res;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``Console.Write(getMinSquares(6));``    ``}``}` `// This code is contributed by nitin mittal`

## PHP

 ` ``\$n``)``            ``break``;``        ``else``            ``\$res` `= min(``\$res``, 1 +``                       ``getMinSquares(``\$n` `-``                                     ``\$temp``));``    ``}``    ``return` `\$res``;``}` `// Driver Code``echo` `getMinSquares(6);` `// This code is contributed``// by nitin mittal.``?>`

## Javascript

 ``
Output
`3`

The time complexity of the above solution is exponential. If we draw the recursion tree, we can observe that many subproblems are solved again and again. For example, when we start from n = 6, we can reach 4 by subtracting one 2 times and by subtracting 2 one times. So the subproblem for 4 is called twice.

Since the same subproblems are called again, this problem has the Overlapping Subproblems property. So min square sum problem has both properties (see this and this) of a dynamic programming problem. Like other typical Dynamic Programming(DP) problems, recomputations of the same subproblems can be avoided by constructing a temporary array table[][] in a bottom-up manner. Below is a Dynamic programming-based solution.

## C++

 `// A dynamic programming based``// C++ program to find minimum``// number of squares whose sum``// is equal to a given number``#include ``using` `namespace` `std;` `// Returns count of minimum``// squares that sum to n``int` `getMinSquares(``int` `n)``{``    ``// We need to check base case``    ``// for n i.e. 0,1,2``    ``// the below array creation``    ``// will go OutOfBounds.``    ``if``(n<=3)``      ``return` `n;``    ` `    ``// Create a dynamic``    ``// programming table``    ``// to store sq``    ``int``* dp = ``new` `int``[n + 1];` `    ``// getMinSquares table``    ``// for base case entries``    ``dp = 0;``    ``dp = 1;``    ``dp = 2;``    ``dp = 3;` `    ``// getMinSquares rest of the``    ``// table using recursive``    ``// formula``    ``for` `(``int` `i = 4; i <= n; i++)``    ``{``        ` `        ``// max value is i as i can``        ``// always be represented``        ``// as 1*1 + 1*1 + ...``        ``dp[i] = i;` `        ``// Go through all smaller numbers to``        ``// to recursively find minimum``        ``for` `(``int` `x = 1; x <= ``ceil``(``sqrt``(i)); x++)``        ``{``            ``int` `temp = x * x;``            ``if` `(temp > i)``                ``break``;``            ``else``                ``dp[i] = min(dp[i], 1 +``                                  ``dp[i - temp]);``        ``}``    ``}` `    ``// Store result and free dp[]``    ``int` `res = dp[n];``    ``delete``[] dp;` `    ``return` `res;``}` `// Driver code``int` `main()``{``    ``cout << getMinSquares(6);``    ``return` `0;``}`

## Java

 `// A dynamic programming based``// JAVA program to find minimum``// number of squares whose sum``// is equal to a given number``class` `squares``{` `    ``// Returns count of minimum``    ``// squares that sum to n``    ``static` `int` `getMinSquares(``int` `n)``    ``{` `        ``// We need to add a check``        ``// here for n. If user enters``        ``// 0 or 1 or 2``        ``// the below array creation``        ``// will go OutOfBounds.``        ``if` `(n <= ``3``)``            ``return` `n;` `        ``// Create a dynamic programming``        ``// table``        ``// to store sq``        ``int` `dp[] = ``new` `int``[n + ``1``];` `        ``// getMinSquares table for``        ``// base case entries``        ``dp[``0``] = ``0``;``        ``dp[``1``] = ``1``;``        ``dp[``2``] = ``2``;``        ``dp[``3``] = ``3``;` `        ``// getMinSquares rest of the``        ``// table using recursive``        ``// formula``        ``for` `(``int` `i = ``4``; i <= n; i++)``        ``{``        ` `            ``// max value is i as i can``            ``// always be represented``            ``// as 1*1 + 1*1 + ...``            ``dp[i] = i;` `            ``// Go through all smaller numbers to``            ``// to recursively find minimum``            ``for` `(``int` `x = ``1``; x <= Math.ceil(``                              ``Math.sqrt(i)); x++)``            ``{``                ``int` `temp = x * x;``                ``if` `(temp > i)``                    ``break``;``                ``else``                    ``dp[i] = Math.min(dp[i], ``1``                                  ``+ dp[i - temp]);``            ``}``        ``}` `        ``// Store result and free dp[]``        ``int` `res = dp[n];` `        ``return` `res;``    ``}``  ` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``System.out.println(getMinSquares(``6``));``    ``}``} ``/* This code is contributed by Rajat Mishra */`

## Python3

 `# A dynamic programming based Python``# program to find minimum number of``# squares whose sum is equal to a``# given number``from` `math ``import` `ceil, sqrt` `# Returns count of minimum squares``# that sum to n``def` `getMinSquares(n):` `    ``# Create a dynamic programming table``    ``# to store sq and getMinSquares table``    ``# for base case entries``    ``dp ``=` `[``0``, ``1``, ``2``, ``3``]` `    ``# getMinSquares rest of the table``    ``# using recursive formula``    ``for` `i ``in` `range``(``4``, n ``+` `1``):``        ` `        ``# max value is i as i can always``        ``# be represented as 1 * 1 + 1 * 1 + ...``        ``dp.append(i)` `        ``# Go through all smaller numbers``        ``# to recursively find minimum``        ``for` `x ``in` `range``(``1``, ``int``(ceil(sqrt(i))) ``+` `1``):``            ``temp ``=` `x ``*` `x;``            ``if` `temp > i:``                ``break``            ``else``:``                ``dp[i] ``=` `min``(dp[i], ``1` `+` `dp[i``-``temp])` `    ``# Store result``    ``return` `dp[n]` `# Driver code``print``(getMinSquares(``6``))` `# This code is contributed by nuclode`

## C#

 `// A dynamic programming based``// C# program to find minimum``// number of squares whose sum``// is equal to a given number``using` `System;` `class` `squares``{` `    ``// Returns count of minimum``    ``// squares that sum to n``    ``static` `int` `getMinSquares(``int` `n)``    ``{` `        ``// We need to add a check here``        ``// for n. If user enters 0 or 1 or 2``        ``// the below array creation will go``        ``// OutOfBounds.` `        ``if` `(n <= 3)``            ``return` `n;` `        ``// Create a dynamic programming``        ``// table to store sq``        ``int``[] dp = ``new` `int``[n + 1];` `        ``// getMinSquares table for base``        ``// case entries``        ``dp = 0;``        ``dp = 1;``        ``dp = 2;``        ``dp = 3;` `        ``// getMinSquares for rest of the``        ``// table using recursive formula``        ``for` `(``int` `i = 4; i <= n; i++)``        ``{``        ` `            ``// max value is i as i can``            ``// always be represented``            ``// as 1 * 1 + 1 * 1 + ...``            ``dp[i] = i;` `            ``// Go through all smaller numbers to``            ``// to recursively find minimum``            ``for` `(``int` `x = 1; x <= Math.Ceiling(``                              ``Math.Sqrt(i)); x++)``            ``{``                ``int` `temp = x * x;``                ``if` `(temp > i)``                    ``break``;``                ``else``                    ``dp[i] = Math.Min(dp[i], 1 +``                                    ``dp[i - temp]);``            ``}``        ``}` `        ``// Store result and free dp[]``        ``int` `res = dp[n];` `        ``return` `res;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``Console.Write(getMinSquares(6));``    ``}``}` `// This code is contributed by Nitin Mittal.`

## PHP

 ` ``\$i``)``                ``break``;``            ``else` `\$dp``[``\$i``] = min(``\$dp``[``\$i``],``                       ``(1 + ``\$dp``[``\$i` `- ``\$temp``]));``        ``}``    ``}` `    ``// Store result``    ``// and free dp[]``    ``\$res` `= ``\$dp``[``\$n``];` `    ``// delete \$dp;``    ``return` `\$res``;``}` `// Driver Code``echo` `getMinSquares(6);``    ` `// This code is contributed``// by shiv_bhakt.``?>`

## Javascript

 ``
Output
`3`

Thanks to Gaurav Ahirwar for suggesting this solution.

Another Approach: (USING MEMOIZATION)

The problem can be solved using the memoization method (dynamic programming) as well.

Below is the implementation:

## C++

 `#include ``using` `namespace` `std;` `int` `minCount(``int` `n)` `{` `    ``int``* minSquaresRequired = ``new` `int``[n + 1];` `    ``minSquaresRequired = 0;` `    ``minSquaresRequired = 1;` `    ``for` `(``int` `i = 2; i <= n; ++i)` `    ``{` `        ``minSquaresRequired[i] = INT_MAX;` `        ``for` `(``int` `j = 1; i - (j * j) >= 0; ++j)` `        ``{` `            ``minSquaresRequired[i]``                ``= min(minSquaresRequired[i],``                      ``minSquaresRequired[i - (j * j)]);``        ``}` `        ``minSquaresRequired[i] += 1;``    ``}` `    ``int` `result = minSquaresRequired[n];` `    ``delete``[] minSquaresRequired;` `    ``return` `result;``}` `// Driver code``int` `main()``{``    ``cout << minCount(6);``    ``return` `0;``}`
Output
`3`

Another Approach:
This problem can also be solved by using graphs. Here is the basic idea of how it can be done.
We will use BFS (Breadth-First Search) to find the minimum number of steps from a given value of n to 0.
So, for every node, we will push the next possible valid path which is not visited yet into a queue and,
and if it reaches node 0, we will update our answer if it is less than the answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count minimum``// squares that sum to n``int` `numSquares(``int` `n)``{`` ` `  ``// Creating visited vector``  ``// of size n + 1``  ``vector<``int``> visited(n + 1,0);``  ` `  ``// Queue of pair to store node``  ``// and number of steps``  ``queue< pair<``int``,``int``> >q;``  ` `  ``// Initially ans variable is``  ``// initialized with inf``  ``int` `ans = INT_MAX;``  ` `  ``// Push starting node with 0``  ``// 0 indicate current number``  ``// of step to reach n``  ``q.push({n,0});``  ` `  ``// Mark starting node visited``  ``visited[n] = 1;``  ``while``(!q.empty())``  ``{``    ``pair<``int``,``int``> p;``    ``p = q.front();``    ``q.pop();` `    ``// If node reaches its destination``    ``// 0 update it with answer``    ``if``(p.first == 0)``      ``ans=min(ans, p.second);` `    ``// Loop for all possible path from``    ``// 1 to i*i <= current node(p.first)``    ``for``(``int` `i = 1; i * i <= p.first; 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=(p.first - (i*i));` `      ``// Check if it is valid and``      ``// not visited yet``      ``if``(path >= 0 && ( !visited[path]``                             ``|| path == 0))``      ``{``        ` `        ``// Mark visited``        ``visited[path]=1;``        ` `        ``// Push it it Queue``        ``q.push({path,p.second + 1});``      ``}``    ``}``  ``}``  ` `  ``// Return ans to calling function``  ``return` `ans;``}` `// Driver code``int` `main()``{``  ``cout << numSquares(12);``  ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``import` `java.awt.Point;``class` `GFG``{``  ``// Function to count minimum``  ``// squares that sum to n``  ``public` `static` `int` `numSquares(``int` `n)``  ``{` `    ``// Creating visited vector``    ``// of size n + 1``    ``int` `visited[] = ``new` `int``[n + ``1``];` `    ``// Queue of pair to store node``    ``// and number of steps``    ``Queue q = ``new` `LinkedList<>();` `    ``// Initially ans variable is``    ``// initialized with inf``    ``int` `ans = Integer.MAX_VALUE;` `    ``// Push starting node with 0``    ``// 0 indicate current number``    ``// of step to reach n``    ``q.add(``new` `Point(n, ``0``));` `    ``// Mark starting node visited``    ``visited[n] = ``1``;``    ``while``(q.size() != ``0``)``    ``{``      ``Point p = q.peek();``      ``q.poll();` `      ``// If node reaches its destination``      ``// 0 update it with answer``      ``if``(p.x == ``0``)``        ``ans = Math.min(ans, p.y);` `      ``// Loop for all possible path from``      ``// 1 to i*i <= current node(p.first)``      ``for``(``int` `i = ``1``; i * i <= p.x; 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 = (p.x - (i * i));` `        ``// Check if it is valid and``        ``// not visited yet``        ``if``(path >= ``0` `&& (visited[path] == ``0` `|| path == ``0``))``        ``{` `          ``// Mark visited``          ``visited[path] = ``1``;` `          ``// Push it it Queue``          ``q.add(``new` `Point(path, p.y + ``1``));``        ``}``      ``}``    ``}` `    ``// Return ans to calling function``    ``return` `ans;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``System.out.println(numSquares(``12``));``  ``}``}` `// This code is contributed by divyesh072019`

## Python3

 `# Python3 program for the above approach``import` `sys` `# Function to count minimum``# squares that sum to n``def` `numSquares(n) :` `    ``# Creating visited vector``    ``# of size n + 1``    ``visited ``=` `[``0``]``*``(n ``+` `1``)``    ` `    ``# Queue of pair to store node``    ``# and number of steps``    ``q ``=` `[]``    ` `    ``# Initially ans variable is``    ``# initialized with inf``    ``ans ``=` `sys.maxsize``    ` `    ``# Push starting node with 0``    ``# 0 indicate current number``    ``# of step to reach n``    ``q.append([n, ``0``])``    ` `    ``# Mark starting node visited``    ``visited[n] ``=` `1``    ``while``(``len``(q) > ``0``) :``        ` `        ``p ``=` `q[``0``]``        ``q.pop(``0``)``    ` `        ``# If node reaches its destination``        ``# 0 update it with answer``        ``if``(p[``0``] ``=``=` `0``) :``            ``ans ``=` `min``(ans, p[``1``])``    ` `        ``# Loop for all possible path from``        ``# 1 to i*i <= current node(p.first)``        ``i ``=` `1``        ``while` `i ``*` `i <``=` `p[``0``] :``          ` `            ``# 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)``            ``path ``=` `p[``0``] ``-` `i ``*` `i``        ` `            ``# Check if it is valid and``            ``# not visited yet``            ``if` `path >``=` `0` `and` `(visited[path] ``=``=` `0` `or` `path ``=``=` `0``) :``            ` `                ``# Mark visited``                ``visited[path] ``=` `1` `                ` `                ``# Push it it Queue``                ``q.append([path,p[``1``] ``+` `1``])``            ` `            ``i ``+``=` `1``    ` `    ``# Return ans to calling function``    ``return` `ans` `print``(numSquares(``12``))` `# This code is contributed by divyeshrabadiya07`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;` `class` `GFG{``  ` `public` `class` `Point``{``    ``public` `int` `x, y;``    ` `    ``public` `Point(``int` `x, ``int` `y)``    ``{``        ``this``.x = x;``        ``this``.y = y;``    ``}``}` `// Function to count minimum``// squares that sum to n``public` `static` `int` `numSquares(``int` `n)``{``    ` `    ``// Creating visited vector``    ``// of size n + 1``    ``int` `[]visited = ``new` `int``[n + 1];``    ` `    ``// Queue of pair to store node``    ``// and number of steps``    ``Queue q = ``new` `Queue();``    ` `    ``// Initially ans variable is``    ``// initialized with inf``    ``int` `ans = 1000000000;``    ` `    ``// Push starting node with 0``    ``// 0 indicate current number``    ``// of step to reach n``    ``q.Enqueue(``new` `Point(n, 0));``    ` `    ``// Mark starting node visited``    ``visited[n] = 1;``    ` `    ``while``(q.Count != 0)``    ``{``        ``Point p = (Point)q.Dequeue();``        ` `        ``// If node reaches its destination``        ``// 0 update it with answer``        ``if` `(p.x == 0)``            ``ans = Math.Min(ans, p.y);``        ` `        ``// Loop for all possible path from``        ``// 1 to i*i <= current node(p.first)``        ``for``(``int` `i = 1; i * i <= p.x; 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 = (p.x - (i * i));``            ` `            ``// Check if it is valid and``            ``// not visited yet``            ``if` `(path >= 0 && (visited[path] == 0 ||``                                       ``path == 0))``            ``{``                ` `                ``// Mark visited``                ``visited[path] = 1;``                ` `                ``// Push it it Queue``                ``q.Enqueue(``new` `Point(path, p.y + 1));``            ``}``        ``}``    ``}``    ` `    ``// Return ans to calling function``    ``return` `ans;``}` `// Driver code``public` `static` `void` `Main(``string``[] args)``{``    ``Console.Write(numSquares(12));``}``}` `// This code is contributed by rutvik_56`
Output
`3`

The time complexity of the above problem is O(n)*sqrt(n) which is better than the Recursive approach.
Also, it is a great way to understand how BFS (Breadth-First Search) works.